昨天晚上睡觉前写的，刚开始学，很多东西都不会，有写的不对的地方，请大家帮忙给指出来
试着运行了一下，递归方法求求斐波那锲数列的时候速度真慢……

1. /*递归方式求斐波那锲数列*/
   
2. class Test
   
3. {
   
4.     public static void main(String[] args)
   
5.     {
   
6.         int n=100;
   
7.         pringFib(n);
   
8.     }
   
9. 
   
10.     public static double Fib(int n)
    
11.     {
    
12.         if(n>2)
    
13.         {
    
14.             return Fib(n-2)+Fib(n-1);
    
15.         }
    
16.         else
    
17.         {
    
18.             return 1;
    
19.         }
    
20.     }
    
21.     public static void pringFib(int n)
    
22.     {
    
23.         for(int x=1;x<=n;x++)
    
24.             if(x!=n)
    
25.         {
    
26.                 System.out.print(Fib(x)+"    ");
    
27.                 if(x%5==0)
    
28.                     System.out.println();
    
29.         }
    
30.             else
    
31.                 System.out.print(Fib(x));
    
32.         System.out.println();
    
33.     }
    
34. }

复制代码

1. /*循环方式求斐波那锲数列*/
   
2. class Test
   
3. {
   
4.     public static void main(String[] args)
   
5.     {
   
6.         printFib(100);
   
7.     }
   
8.     public static double[] Fib(double[] arr)
   
9.     {
   
10.         arr[0]=1;
    
11.         arr[1]=1;
    
12.         for (int i = 2; i < arr.length; i++) {
    
13.             arr[i]=arr[i-2]+arr[i-1];
    
14.         }
    
15.         return arr;
    
16.         
    
17.     }
    
18.     public static void printFib(int n)
    
19.     {
    
20.         double[] arr=new double[n];
    
21.         Fib(arr);
    
22.         for (int i = 0; i < arr.length; i++) {
    
23.             if(i!=arr.length-1)
    
24.                 System.out.print(arr[i]+"    ");
    
25.             else
    
26.                 System.out.println(arr[i]);
    
27.             if((i+1)%5==0)
    
28.                 System.out.println();
    
29.         }        
    
30.     }
    
31. }

复制代码

1. class demo {
   
2.         public static void main(String[] args) {
   
3.                 int n = IndexOf(102334155);
   
4.                 System.out.println(n);
   
5.                 System.out.println(feibo(n));
   
6.         }
   
7. 
   
8.         public static int feibo(int num){
   
9.                 if(num==1||num==2)
   
10.                         return 1;
    
11.                
    
12.                 return feibo(num-2)+feibo(num-1);
    
13.         }
    
14. 
    
15.         public static int IndexOf(int num){
    
16.                 int sum = 1;
    
17.                 int last = 1;
    
18.                 int temp;
    
19. 
    
20.                 int i = 2;
    
21.                 while(true){
    
22.                         temp = sum;
    
23.                         sum += last;
    
24.                         last = temp;
    
25.                         i++;
    
26.                         if (num <= sum)
    
27.                         {
    
28.                                 return i;
    
29.                         }
    
30.                 }
    
31.         }
    
32. }

复制代码

还是循环省事啊

小弟刚学不久，功力不够深厚，但为了能得分也只好献丑了。
一般情况下能用循环解决问题的，都不建议用递归，根据问题要求，我用while循环写了两个函数，并且已经在我机子上运行
class Num
{
        public static long getNum(int n)
        {
                long [] num = new long [n];
                if(n<=2)
                {
                        return 1;
                }
                num[0] = 1;
                num[1] = 1;
                int i = 2;
                while(i<n)
                {
                        num[i] = num[i-1] + num[i-2];
                        i++;
                }
                return num[i-1];
        }
       
        public static int getIndex(long num)
        {
               
                long arr [] = new long[200] ;
                if(num<2)
                {
                        return 1;
                }
                arr[0] = 1;
                arr[1] = 2;
                int n=2;
                do
                {
                        arr[n] = arr[n-1] + arr[n-2];
                        n++;
                }while (arr[n-1]<num);
                if(arr[n -1] == num)
                   return n;
                else
                {
                        System.out.println(num+"不是数列中的元素");
                        return 0;
                }
        }
                public static void main(String args[])
                {
                        long i = getNum(100);
                        int j = getIndex(102334155L);
                        System.out.println("i="+i);
                        System.out.println("j="+j);
                }
       
}
都与LZ提到的第二个问题，也很简单，只要判断每一项的值是否小于给定的数就行了，如果不小于就只有两种情况，要么等于，那么返回下标就行了，如果不等于，那么就说明该数在数列中不存在.

1. 
   

复制代码