Java遞歸算法

1.漢諾塔問題
import javax.swing.JOptionPane;
　　public class Hanoi {
　　private static final String DISK_B = "diskB";
　　private static final String DISK_C = "diskC";
　　private static final String DISK_A = "diskA";
　　static String from=DISK_A;
　　static String to=DISK_C;
　　static String mid=DISK_B;
　　public static void main(String[] args) {
　　String input=JOptionPane.showInputDialog("please input the number of the disks you want me move.");
　　int num=Integer.parseInt(input);
　　move(num，from，mid，to);
　　}
　　private static void move(int num， String from2， String mid2， String to2) {
　　if(num==1){
　　System.out.println("move disk 1 from "+from2+" to "+to2);
　　}
　　else {
　　move(num-1，from2，to2，mid2);
　　System.out.println("move disk "+num+" from "+from2+" to "+to2);
　　move(num-1，mid2，from2，to2);
　　}
　　}
　　}
2. 這是一個排列的例子，它所做的工作是將輸入的一個字符串中的所有元素進行排序並輸出，例如：你給出的參數是"abc" 則程序會輸出：
　　abc
　　acb
　　bac
　　bca
　　cab
　　cba
　　(1)算法的出口在於：low=high也就是現在給出的排列元素只有一個時。
　　(2)算法的逼近過程：先確定排列的第一位元素，也就是循環中i所代表的元素，
　　然後low+1開始減少排列元素，如此下去，直到low=high
　　public static void permute(String str) {
　　char[] strArray = str.toCharArray();
　　permute(strArray， 0， strArray.length - 1);
　　}
　　public static void permute(char[] list， int low， int high) {
　　int i;
　　if (low == high) {
　　String cout = "";
　　for (i = 0; i <= high; i++)
　　cout += list[i];
　　System.out.println(cout);
　　} else {
　　for (i = low; i <= high; i++) {
　　char temp = list[low];
　　list[low] = list[i];
　　list[i] = temp;
　　permute(list， low + 1， high);
　　temp = list[low];
　　list[low] = list[i];
　　list[i] = temp;
　　}
　　}
　　}
　　3。這是一個組合的例子，與上述的例子相似，只是它所做的工作是，輸出所給字符串中制定數目的元素的組合種類
　　(1)程序出口在於n=1，此時只要輸出目標數組的所有元素即可
　　(2)逼近過程，當n>1　的時候，我們先取第一個元素放入目標數組中，然後n-1，如此下去，最後出來。
　　import javax.swing.JOptionPane;
　　public class Combination {
　　
　　public static void main(String[] args) {
　　String input = JOptionPane.showInputDialog("please input your String： ");
　　String numString = JOptionPane.showInputDialog("please input the number of your Combination： ");
　　int num = Integer.parseInt(numString);
　　Combine(input， num);
　　}
　　private static void Combine(String input， int num) {
　　char[] a = input.toCharArray();
　　String b = "";
　　Combine(a， num， b， 0， a.length);
　　}
　　private static void Combine(char[] a， int num， String b， int low， int high) {
　　if (num == 0) {
　　System.out.println(b);
　　} else {
　　for (int i = low; i < a.length; i++) {
　　b += a[i];
　　Combine(a， num - 1， b， i+1， a.length);
　　b=b.substring(0， b.length()-1);
　　}
　　}
　　}
　　}

 

Coding多了，遞歸算法是非常常見的，最近我一直在做樹形結構的封裝，所以更加的離不開遞歸算法。所以今天就簡單說一下這個遞歸算法，用java實現一個非常經典的遞歸實例。
 
        遞歸算法，其實說白了，就是程序的自身調用。它表現在一段程序中往往會遇到調用自身的那樣一種coding策略，這樣我們就可以利用大道至簡的思想，把一個大的複雜的問題層層轉換爲一個小的和原問題相似的問題來求解的這樣一種策略。這樣我們就能看到我們會用很少的語句解決了非常大的問題，所以遞歸策略的最主要體現就是小的代碼量解決了非常複雜的問題。
 
        做過樹形結構的都知道，我們有時候遇到的樹是無限級別的樹，這樣我們就必須要利用循環和遞歸算法來實現無限級別的樹。
 
        在做遞歸算法的時候，一定要把握住出口，也就是做遞歸算法必須要有一個明確的遞歸結束條件。這一點是非常重要的。其實這個出口是非常好理解的，就是一個條件，當滿足了這個條件的時候我們就不再遞歸了。
 
       下面用一個java的實例來實現一下遞歸算法。

        問題描述：

 
       Java代碼清單：

[java] 
package com.cjq.filedown; 
  
public classFab { 
   
   public static void main(String args[]){ 
      System.out.println(fab(5)); 
   } 
   
   private static int fab(int index){ 
      if(index==1 || index==2){ 
         return 1; 
      }else{ 
         return fab(index-1)+fab(index-2); 
      } 
   } 
} 
  

          運行結果：

 
        程序分析：
                這個實例是非常經典的實例，主要是利用遞歸實現了Fibonacci數列。這個遞歸算法的出口是在
[java] view plaincopyprint?
if(index==1 || index==2){ 
   return 1; 
} 
                這個代碼段上，如果程序的index符合條件就會停止進行遞歸。所以這個程序的運行流程是：
        
      
        程序分析到這裏，遞歸的實現也就完成了，讀者可以自己簡單的做個demo，感受一下這個算法的精妙之處，其實很多人都在說算法難，難於上青天，其實掌握算法的根纔是最重要的，什麼是算法的根呢，就拿這個遞歸算法來說吧，我感覺這個根就是那個出口，只要找到這個出口所在，那麼算法自然而然就能水到渠成了。