c# 遞歸算法

2009-03-13 09:44 6950人閱讀 評論(8) 收藏 舉報

算法 c# fun n2 c

 1）1、1、2、3、5、8.......用遞歸算法求第30位數的值？

  首先我們可以發現從第3位數起后一位數等於前兩位數值之和，即：x=（x-1）+（x-2），x>2;

  這里需要不斷的相加，第一時刻就會想到循環處理，我們嘗試用數組去裝載這些數值，即：

  int[] a=new int[30];

 a[0]=1;

 a[1]=1;

 for(int i=2;i<30;i++)

{

    a[i]=a[i-1]+a[i-2];

}

求a[29]的值即為第30位數的值。

遞歸該如何處理呢？同樣定義函數

fun(n)

{

    return fun(n-1)+fun(n-2)//n為第幾位數，第n位數返回值等於第n-1位數的值與第n-2位數的值之和

}

只有當n>2為這種情況，就可以做個判斷

fun(n)

{

     if(n==1 || n==2)

          return 1;

     else

          return fun(n-1)+fun(n-2);

}

求fun(30);

 

網站看到別人的分析也不錯：

【問題】 編寫計算斐波那契（Fibonacci）數列的第n項函數fib（n）。 
斐波那契數列為：0、1、1、2、3、……，即： 
fib(0)=0; 
fib(1)=1; 
fib(n)=fib(n-1)+fib(n-2) （當n>1時）。 
寫成遞歸函數有： 
int fib(int n) 
{ if (n==0) return 0; 
if (n==1) return 1; 
if (n>1) return fib(n-1)+fib(n-2); 
} 
遞歸算法的執行過程分遞推和回歸兩個階段。在遞推階段，把較復雜的問題（規模為n）的求解推到比原問題簡單一些的問題（規模小於n）的求解。例如上例中，求解fib(n)，把它推到求解fib(n-1)和fib(n-2)。也就是說，為計算fib(n)，必須先計算fib(n-1)和fib(n-2)，而計算fib(n-1)和fib(n-2)，又必須先計算fib(n-3)和fib(n-4)。依次類推，直至計算fib(1)和fib(0)，分別能立即得到結果1和0。在遞推階段，必須要有終止遞歸的情況。例如在函數fib中，當n為1和0的情況。 
在回歸階段，當獲得最簡單情況的解后，逐級返回，依次得到稍復雜問題的解，例如得到fib(1)和fib(0)后，返回得到fib(2)的結果，……，在得到了fib(n-1)和fib(n-2)的結果后，返回得到fib(n)的結果。 
在編寫遞歸函數時要注意，函數中的局部變量和參數知識局限於當前調用層，當遞推進入“簡單問題”層時，原來層次上的參數和局部變量便被隱蔽起來。在一系列“簡單問題”層，它們各有自己的參數和局部變量。 
由於遞歸引起一系列的函數調用，並且可能會有一系列的重復計算，遞歸算法的執行效率相對較低。當某個遞歸算法能較方便地轉換成遞推算法時，通常按遞推算法編寫程序。例如上例計算斐波那契數列的第n項的函數fib(n)應采用遞推算法，即從斐波那契數列的前兩項出發，逐次由前兩項計算出下一項，直至計算出要求的第n項。

 

其他遞歸解題：

求1+2+3+4+5+....+n的值

Fun(n)=n+Fun(n-1)

n=1時為1

Fun(n)

{

     if(n==1)

       return 1;

     else

      return n+Fun(n-1);

}

 

有兩個整數型數組，從小到大排列，編寫一個算法將其合並到一個數組中，並從小到大排列

    public void Fun()
    {
        int[] a = { 1, 3, 5, 7, 9, 10 };
        int[] b = { 2, 4, 6, 8, 11, 12, 15 };

        int[] c = new int[a.Length + b.Length];
        ArrayList al=new ArrayList();
        int i=0;
        int j=0;
        while (i <= a.Length - 1 && j <= b.Length - 1)
        {  //循環比較把小的放到前面
            if (a[i] < b[j])
            {
                al.Add(a[i++]);
            }
            else
            {
                al.Add(b[j++]);
            }
        }

        //兩個數組的長度不一樣，必有個數組沒比較完
        while (i <= a.Length - 1)//添加a中剩下的
        {
            al.Add(a[i++]);
        }
        while (j <= b.Length - 1)//添加b中剩下的

        {
            al.Add(b[j++]);
        }

        for (int ii = 0; ii <= c.Length-1 ; ii++)
        {
            c[ii] = (int)al[ii];
        }
    }

 

 

----------------------------------------------------

 

      首先碰到的是這樣的一首題目：計算數組{1,1,2,3,5,8.......} 第30位值，不用遞歸，我寫出了以下這樣的代碼：

 

        static void Main(string[] args)
         {


            int[] num=new int[30];
            num[0]=1;
            num[1]=1;
            int first=num[0];
            int second=num[1];
            for (int i = 2; i < num.Length; i++)
            {
                num[i] = first + second;
                first = second;
                second = num[i];
            }
            Console.WriteLine(num[29]);
            Console.ReadLine();

         

        }

 寫出來，十分的累贅，於是改為歸遞算法來寫，一目了然，十分明了。以下是代碼：

 

        static void Main(string[] args)
         {

            Console.WriteLine(Process1(30));
            Console.ReadLine();        
        }
        public static int Process1(int i)
        {




            //計算數組{1,1,2,3,5,8.......} 第30位值
            if (i == 0) return 0;
            if (i == 1) return 1;
            else
                return Process1(i - 1) + Process1(i - 2);
        }

做了一些練習：

1. 計算1+2+3+4+...+100的值

 

        static void Main(string[] args)
         {
            Console.WriteLine(Process2(100));
            Console.ReadLine();    
        }
        public static int Process2(int i)
        {
            //計算1+2+3+4+...+100的值
            if (i == 0) return 0;
            return Process2(i - 1) + i;

        }

2. 計算1 -2 +3 +-4+ 5- 6 + 7 - 8 + 9的值

 

        static void Main(string[] args)
         {

            Console.WriteLine(Process3(9) - Process3(8));
            Console.ReadLine();  
        }

        public static int Process3(int i)
        {
            //計算1 -2 +3 +-4+ 5- 6 + 7 - 8 + 9的值
            if (i == 0) return 1;
            if (i == 1) return 2;
            else return Process3(i - 2) + i;
        }

3.漢諾塔問題

 

        static void Main(string[] args)
         {
            Hanoi(5, 'A', 'B', 'C');
            Console.ReadLine();
        }
        public static void Hanoi(int n ,char A, char B, char C)
        {
            //漢諾塔問題
            //將n個盤子從A座借助B座，移到C座
            if (n == 1) Move(A, C);
            else
            {
                Hanoi(n - 1, A, C, B);
                Move(A, C);
                Hanoi(n - 1, B, A, C);
            }

        }
        public static void Move(char startPlace, char endPlace)
        {
            Console.WriteLine("Move {0} To {1}",startPlace,endPlace);
        }

4.用遞歸法將一個整數n轉換成字符串，例如，輸入483,就輸出字符串"483".n的位數不確定，可以是任意位數的整數。

 

        static void Main(string[] args)
         {
            IntToString(483, "");
            Console.ReadLine();
        }
        public static void IntToString(int input,String output)
        {
         //用遞歸法將一個整數n轉換成字符串，例如，輸入483,就輸出字符串"483".n的位數不確定，可以是任意位數的整數。
         //   String output = "";
            output = input % 10+output;
            if (input / 10 != 0)
            {
                IntToString(input / 10,output);
            }
            else Console.WriteLine(output);
        }

 

------------------------------------------二分查找算法：http://blog.csdn.net/dinglang_2009/article/category/1435813

package com.dylan.algorithm;

import javax.sound.sampled.Mixer;

public class BinarySearch {

    public static void main(String[] args) {
        // TODO Auto-generated method stub

         int arr[] ={10,24,36,47,68,89,130};
         int index = Search(arr, 89);
         System.out.println(index);
    }
    /*實現二分查找算法（折半算法）
     *要確定數組是排序好的
     *最好是里面一定包含該元素
     */
    public static int  Search(int[] arr,int key ) {

          int min =0;
          int max=arr.length-1;
          int mid = (min+max)/2;
          while(arr[mid]!=key){
              if (arr[mid]<key) {
                 min=mid+1;
                }else if (arr[mid]>key) {
                 max=mid-1;
               }
             if(max<min){
                 return -1;//里面不存在值為key的元素
             }
             //繼續折半
             mid=(min+max)/2;
          }

        return mid;
    }

}