遞歸

1、遞歸簡介

1. 使用遞歸就是使用遞歸方法（recursive method)編程，遞歸方法就是直接或間接調用本身的方法。
2. 遞歸方法的特色
   • 這些方法使用if-else或switch語句會致使不一樣的狀況
   • 一個或多個基礎狀況用來中止遞歸
   • 每次遞歸都會簡化原始問題，讓它不斷地接近基礎狀況，直到它變爲基礎狀況

2、兩個基礎遞歸問題：

1.計算階乘

階乘的定義：

0！=1；

n!=n*(n-1)*...*2*1=n*(n-1)!;  (n>0)

 1  import  java.util.Scanner;
 2  public class ComputeFactorial{
 3      public static void main(String[] args){
 4          Scanner input=new Scanner(System.in);
 5          System.out.print("Enter a nonnegtive integer:");
 6          int n=input.nextInt();
 7          System.out.println(n+"!="+factorial(n));
 8      }
 9      private static int factorial(int n){
10          if(n==0)
11          return 1;
12          else 
13          return n*factorial(n-1);
14      }
15  }

2.計算斐波那契數

斐波那契數的定義：

fib(0)=0;

fib(1)=1;

fib(index)=fib(index-1)+fib(index-2); index>=2

 1  import  java.util.Scanner;
 2  public class ComputeFibonacci{
 3      public static void main(String[] args){
 4          Scanner input=new Scanner(System.in);
 5          System.out.print("Enter an index for Fobonacci number:");
 6          int n=input.nextInt();
 7          System.out.println(fib(n));
 8      }
 9      private static int fib(int n){
10          if(n==0)
11          return 0;
12          else if(n==1)
13          return 1;
14          else 
15          return fib(n-1)+fib(n-2);
16      }
17  }

以上兩個例子只是用來演示遞歸的概念，實際上用循環來實現效率更高，代碼以下：

 1 //階乘
 2 import  java.util.Scanner;
 3  public class ComputeFactorial{
 4      public static void main(String[] args){
 5          Scanner input=new Scanner(System.in);
 6          System.out.print("Enter a nonnegtive integer:");
 7          int n=input.nextInt();
 8          int n0=n;
 9          int s=1;
10          while(n>0)
11          {
12           s*=n--;        
13          }
14          System.out.println(n0+"!="+ s);
15      } 
16 }

 1 //斐波那契數
 2 import  java.util.Scanner;
 3  public class ComputeFibonacci{
 4      public static void main(String[] args){
 5          Scanner input=new Scanner(System.in);
 6          System.out.print("Enter an index for Fobonacci number:");
 7          int n=input.nextInt();
 8          int f0=0,f1=1,currentFib=0;
 9          for(int i=2;i<=n;i++){
10              currentFib=f0+f1;
11              f0=f1;
12              f1=currentFib;
13          }
14          System.out.println(currentFib);
15      }
16  }

3、遞歸的輔助方法

1.遞歸的輔助方法

用遞歸的思路解決迴文字符串問題：

 1  import  java.util.Scanner;
 2  public class Palindrome{
 3      public static void main(String[] args){
 4          Scanner input=new Scanner(System.in);
 5          System.out.print("Enter a string:");
 6          String text=input.nextLine();
 7          System.out.println(isPalindrome(text));
 8      }
 9      private static boolean isPalindrome(String text){
10          if(text.length()<=1)
11          return true;
12          else if(text.charAt(0)!=text.charAt(text.length()-1))
13          return false;
14          else
15          return isPalindrome(text.substring(1,text.length()-1));
16      }
17    
18  }

因爲每次遞歸時都要建立一個新的字符串，所以不夠高效。爲避免建立新字符串，可使用low和high下標來代表子串的範圍。

 1  import  java.util.Scanner;
 2  public class Palindrome{
 3      public static void main(String[] args){
 4          Scanner input=new Scanner(System.in);
 5          System.out.print("Enter a string:");
 6          String text=input.nextLine();
 7          System.out.println(isPalindrome(text));
 8      }
 9      private static boolean isPalindrome(String text){
10           return isPalindrome(text,0,text.length()-1);
11      }
12      private static boolean isPalindrome(String text,int low,int high){
13          if(low>=high)
14          return true;
15          else if(text.charAt(low)!=text.charAt(high))
16          return false;
17          else
18          return isPalindrome(text,low+1,high-1);
19      }
20    
21  }

程序中定義了兩個重載的isPalindrome方法，第一個方法將low和high的值傳遞給第二個方法，第二個方法採用遞歸調用，檢測不斷縮小的子串是否迴文。在遞歸程序設計中定義第二個方法來接收附加的參數是一種經常使用的技巧，稱爲遞歸的輔助方法。

2.遞歸的輔助方法舉例

選擇排序

 1 public class RecursiveSeletionSort{
 2     public static void sort(double[] list){
 3         sort(list,0,list.length-1);
 4     }
 5     public static void sort(double[] list,int low,int high){
 6         if(low<high){
 7             int indexOfMin=low;
 8             double min=list[low];
 9             for(int i=low+1;i<=high;i++){
10                 if(min<list[i]){
11                     min=list[i];
12                     indexOfMin=i;
13                 }              
14             }
15             //Swap
16             list[indexOfMin]=list[low];
17             list[low]=min;
18             
19             sort(list,low+1,high);
20         }
21     }
22 }//只是算法，並不是完整程序

二分查找

 1  public class RecursiveBinarySearch{
 2      public static int binarySearch(int[] list,int key){
 3          int low=0;
 4          int high=list.length-1;
 5          return binarySearch(list,key,low,high);
 6      }
 7      public static int binarySearch(int[] list,int key,int low,int high){
 8          if(low>high)
 9          return -low-1;
10          int mid=(low+high)/2;
11          if(key<list[mid])
12          return binarySearch(list,key,low,mid-1);
13          else if(key=list[mid])
14          return mid;
15          else
16          return binarySearch(list,key,mid+1,high);
17      }
18  }//只是算法，並不是完整程序

4、尾遞歸

若是從遞歸調用返回時沒有待定的操做要完成，這個遞歸就稱爲尾遞歸（tail recursive)。某些編譯器會優化尾遞歸以減小桟空間。可使用輔助參數將非尾遞歸轉化爲尾遞歸。

將階乘的例子改成尾遞歸

5、更多例子

1.求出目錄的大小

 1 package book;
 2 
 3 import java.io.File;
 4 import java.util.Scanner;
 5 
 6 public class DirectorySize{
 7     public static void main(String[] args){
 8         System.out.print("Enter a directory or a file:");
 9         Scanner input=new Scanner(System.in);
10         String directory=input.nextLine();
11         
12         System.out.println(getSize(new File(directory))+"bytes");
13         
14         input.close();
15     }
16     public static long getSize(File file){
17         long size=0;
18         if(file.isDirectory()){
19             File[] files=file.listFiles();
20             for(int i=0;i<files.length;i++){
21                 size+=getSize(files[i]);
22             }
23         }
24         else
25         size+=file.length();
26         
27         return size;
28     }
29     
30 }

2.漢諾塔問題

 1  import  java.util.Scanner;
 2  public class TowersOfHanoi{
 3      public static void main(String[] args){
 4          Scanner input=new Scanner(System.in);
 5          System.out.print("Enter number of disks:");
 6          int n=input.nextInt();
 7          System.out.println("The moves are:");
 8          moveDisks(n,'A','B','C');
 9      }
10      private static void moveDisks(int n,char fromTower,char toTower,char auxTower){
11          if(n==1)
12          System.out.println("Move disk "+n+" from "+fromTower+" to "+toTower);
13          else{
14              moveDisks(n-1,fromTower,auxTower,toTower);
15              System.out.println("Move disk "+n+" from "+fromTower+" to "+toTower);
16              moveDisks(n-1,auxTower, toTower,fromTower);
17              
18          }
19          
20      }
21    
22  }

3.八皇后問題

 1 import java.awt.*;
 2 import javax.swing.*;
 3 public class EightQueens extends JApplet{
 4     /**
 5      * 
 6      */
 7     private static final long serialVersionUID = 5660619297259886927L;
 8     public  static final int SIZE=8;
 9     private int[] queens=new int[SIZE];
10     
11     public EightQueens(){
12         search(0);
13         add(new ChessBord(),BorderLayout.CENTER);
14     }
15     
16     private boolean isValid(int row,int cloumn){
17          for(int i=1;i<=row;i++){
18              if(queens[row-i]==cloumn
19              ||queens[row-i]==cloumn-1
20              ||queens[row-i]==cloumn+1)
21              
22              return false;
23          }
24          return true;
25     }
26     
27     private boolean search(int row){
28         if(row==SIZE)
29         return true;
30         
31         for(int cloumn=0;cloumn<SIZE;cloumn++){
32             queens[row]=cloumn;
33             if(isValid(row,cloumn)&&search(row+1))
34             return true;
35         }
36         
37         return false;
38     }
39     
40     class ChessBord extends JPanel{
41         /**
42          * 
43          */
44         private static final long serialVersionUID = 4151757353625344600L;
45         private Image queenImage=new ImageIcon("image/queen.jpg").getImage();
46         
47         ChessBord(){
48             this.setBorder(BorderFactory.createLineBorder(Color.BLACK,2));
49         }
50         protected void paintComponent(Graphics g){
51             super.paintComponent(g);
52             
53             //Paint the queens
54             for(int i=0;i<SIZE;i++){
55                 int j=queens[i];
56                 g.drawImage(queenImage,j*getWidth()/SIZE,i*getHeight()/SIZE,getWidth()/SIZE,getHeight()/SIZE,this);
57             }
58             
59             //Draw the horizontal and vertical lines
60              for(int i=0;i<SIZE;i++){
61                  g.drawLine(0,i*getHeight()/SIZE,getWidth(),i*getHeight()/SIZE);
62                  g.drawLine(i*getWidth()/SIZE,0,i*getWidth()/SIZE,getHeight());
63              }
64             
65         }
66     }
67 }