求第1500个只有2,3,5因子的数
数是从小到大排列
如：第一个数是1,1=2^0*3^0*5^0

C区已经写了个了,楼主看看可以不.

用队列做

在哪呢?
找不到

刚从网上找到的,下午好好看看
#include <stdio.h>
#include <stdlib.h>
#include <time.h>

long number[1600];
char accFlag = 0;
long *pf2 = 0;
long *pf3 = 0;
long *pf5 = 0;

int main()
{
int n;
long max;
long next2, next3, next5;
double t1, t2;

t1 = clock();
number[1] = 1;
pf2 = pf3 = pf5 = number + 1;
next2 = 2;
next3 = 3;
next5 = 5;
for(n = 2; n <= 1500; ++n)
{
max = next2;
accFlag = 1;
if ( next3 < max )
{
max = next3;
accFlag = 2;
}
else if ( next3 == max )
{
accFlag |= 2;
}
if ( next5 < max )
{
max = next5;
accFlag = 4;
}
else if ( next5 == max )
{
accFlag |= 4;
}
number[n] = max;
if ( accFlag & 1 )
{
++pf2;
next2 = *pf2 * 2;
}
if ( accFlag & 2 )
{
++pf3;
next3 = *pf3 * 3;
}
if ( accFlag & 4 )
{
++pf5;
next5 = *pf5 * 5;
}
}
t2 = clock();
printf("Answer = %ld\n", number[1500]);
printf("Total: %f seconds\n", (t2-t1)/CLK_TCK);
return 0;
}

楼上的算法是错误的，不过很接近正确算法，只是考虑的不完全，（不相信的话可以求第10个数试试，顺序是1，2，3，4，5，6，8，9，10，12）
稍微改一下，加上
next6 = 6;
next10 = 10;
next15 = 15;
这三种情况就行了，不过long int 型绝对存储不下最后的结果
解决这个问题我想出了两种算法，一种就是象楼上的那样，不过这种比较麻烦，恐怕还要解决超常整数存储的问题，另一种就简单多了，纯粹的数学运算，只需要注意运算精度就可以了，不过现在没时间了，我要下机了，改天再给出来

//nuciewth 写的代码,稍微改了下,运算时间有点长稍微等一会

#include<stdio.h>

int main()
{
    int n,num,i,j,k,count=0;
    for(num=1;count<=1500;num++)
    {
        i=0,j=0,k=0;
        n=num;
        while(n%2==0)
        {
            n/=2;
            i++;
        }
        while(n%3==0)
        {
            n/=3;
            j++;
        }
        while(n%5==0)
        {
            n/=5;
            k++;
        }
        if(n==1)
         count++;
    }
    printf(\"第1500个数是:%d=2^%d*3^%d*5^%d\n\",num,i,j,k);
    return 0;
}

讲个构造的算法吧.
设所要求的数生成的队列是q。p1=2,p2=3,p3=5;
开一个数组m[4][4].
m[1][1..3]存储p1,p2,p3，
m[2][1...3]是指向q中数字的指针，
m[3][j]=m[1][j]]*q[m[2][j]]。
这样，最初q[1]=1，m[2][i]=1(1<=i<=3)，然后在m[3][i](1<=i<=3)里选一个最小的，存储到队列里去.
并且假设选中的是m[3][k]，那么m[2][k]++,(使指针志向下一个),更新m[3][k],m[3,k]=m[1,k]*q[m[2,k]].
如此循环下去。如果m[3][i](1<=i<=3)中有相等的怎么办？那么把所有的等于最小值的m[3][k]都选出来，全部m[2][k]++; 并更新全部m[3][k],m[3,k]=m[1,k]*q[m[2,k]].
这样算法的时间复杂度几乎是O(n)的.
其实这道题的实质还是动态规划..........

楼上的是正解，不过m[3][i]不可能有重复的值，因为2，3，5都是质数

还是会有相同的值的,比如m[3][i]可以都等于30;
m[3][1]=2*3*5,m[3][2]=3*2*5;m[3][3]=5*2*3(注意顺序)..