递归

一、递归简介

1. 使用递归就是使用递归方法（recursive method)编程，递归方法就是直接或间接调用自己的方法。
2. 递归方法的特点
   • 这些方法使用if-else或switch语句会导致不同的情况
   • 一个或多个基础情况用来停止递归
   • 每次递归都会简化原始问题，让它不断地接近基础情况，直到它变为基础情况

二、两个基础递归问题：

1.计算阶乘

阶乘的定义：

0！=1；

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

 import  java.util.Scanner;
 public class ComputeFactorial{
     public static void main(String[] args){
         Scanner input=new Scanner(System.in);
         System.out.print("Enter a nonnegtive integer:");
         int n=input.nextInt();
         System.out.println(n+"!="+factorial(n));
     }
     private static int factorial(int n){
         if(n==0)
         return 1;
         else 
         return n*factorial(n-1);
     }
 }

2.计算斐波那契数

斐波那契数的定义：

fib(0)=0;

fib(1)=1;

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

 import  java.util.Scanner;
 public class ComputeFibonacci{
     public static void main(String[] args){
         Scanner input=new Scanner(System.in);
         System.out.print("Enter an index for Fobonacci number:");
         int n=input.nextInt();
         System.out.println(fib(n));
     }
     private static int fib(int n){
         if(n==0)
         return 0;
         else if(n==1)
         return 1;
         else 
         return fib(n-1)+fib(n-2);
     }
 }

以上两个例子只是用来演示递归的概念，实际上用循环来实现效率更高，代码如下：

//阶乘
import  java.util.Scanner;
 public class ComputeFactorial{
     public static void main(String[] args){
         Scanner input=new Scanner(System.in);
         System.out.print("Enter a nonnegtive integer:");
         int n=input.nextInt();
         int n0=n;
         int s=1;
         while(n>0)
         {
          s*=n--;        
         }
         System.out.println(n0+"!="+ s);
     } 
}

//斐波那契数
import  java.util.Scanner;
 public class ComputeFibonacci{
     public static void main(String[] args){
         Scanner input=new Scanner(System.in);
         System.out.print("Enter an index for Fobonacci number:");
         int n=input.nextInt();
         int f0=0,f1=1,currentFib=0;
         for(int i=2;i<=n;i++){
             currentFib=f0+f1;
             f0=f1;
             f1=currentFib;
         }
         System.out.println(currentFib);
     }
 }

三、递归的辅助方法

1.递归的辅助方法

用递归的思路解决回文字符串问题：

 import  java.util.Scanner;
 public class Palindrome{
     public static void main(String[] args){
         Scanner input=new Scanner(System.in);
         System.out.print("Enter a string:");
         String text=input.nextLine();
         System.out.println(isPalindrome(text));
     }
     private static boolean isPalindrome(String text){
         if(text.length()<=1)
         return true;
         else if(text.charAt(0)!=text.charAt(text.length()-1))
         return false;
         else
         return isPalindrome(text.substring(1,text.length()-1));
     }
   
 }

由于每次递归时都要创建一个新的字符串，因此不够高效。为避免创建新字符串，可以使用low和high下标来表明子串的范围。

 import  java.util.Scanner;
 public class Palindrome{
     public static void main(String[] args){
         Scanner input=new Scanner(System.in);
         System.out.print("Enter a string:");
         String text=input.nextLine();
         System.out.println(isPalindrome(text));
     }
     private static boolean isPalindrome(String text){
          return isPalindrome(text,0,text.length()-1);
     }
     private static boolean isPalindrome(String text,int low,int high){
         if(low>=high)
         return true;
         else if(text.charAt(low)!=text.charAt(high))
         return false;
         else
         return isPalindrome(text,low+1,high-1);
     }
   
 }

程序中定义了两个重载的isPalindrome方法，第一个方法将low和high的值传递给第二个方法，第二个方法采用递归调用，检测不断缩小的子串是否回文。在递归程序设计中定义第二个方法来接收附加的参数是一种常用的技巧，称为递归的辅助方法。

2.递归的辅助方法举例

选择排序

public class RecursiveSeletionSort{
    public static void sort(double[] list){
        sort(list,0,list.length-1);
    }
    public static void sort(double[] list,int low,int high){
        if(low<high){
            int indexOfMin=low;
            double min=list[low];
            for(int i=low+1;i<=high;i++){
                if(min<list[i]){
                    min=list[i];
                    indexOfMin=i;
                }              
            }
            //Swap
            list[indexOfMin]=list[low];
            list[low]=min;
            
            sort(list,low+1,high);
        }
    }
}//只是算法，并非完整程序

二分查找

 public class RecursiveBinarySearch{
     public static int binarySearch(int[] list,int key){
         int low=0;
         int high=list.length-1;
         return binarySearch(list,key,low,high);
     }
     public static int binarySearch(int[] list,int key,int low,int high){
         if(low>high)
         return -low-1;
         int mid=(low+high)/2;
         if(key<list[mid])
         return binarySearch(list,key,low,mid-1);
         else if(key=list[mid])
         return mid;
         else
         return binarySearch(list,key,mid+1,high);
     }
 }//只是算法，并非完整程序

四、尾递归

如果从递归调用返回时没有待定的操作要完成，这个递归就称为尾递归（tail recursive)。某些编译器会优化尾递归以减少桟空间。可以使用辅助参数将非尾递归转化为尾递归。

将阶乘的例子改为尾递归

五、更多例子

1.求出目录的大小

package book;

import java.io.File;
import java.util.Scanner;

public class DirectorySize{
    public static void main(String[] args){
        System.out.print("Enter a directory or a file:");
        Scanner input=new Scanner(System.in);
        String directory=input.nextLine();
        
        System.out.println(getSize(new File(directory))+"bytes");
        
        input.close();
    }
    public static long getSize(File file){
        long size=0;
        if(file.isDirectory()){
            File[] files=file.listFiles();
            for(int i=0;i<files.length;i++){
                size+=getSize(files[i]);
            }
        }
        else
        size+=file.length();
        
        return size;
    }
    
}

2.汉诺塔问题

 import  java.util.Scanner;
 public class TowersOfHanoi{
     public static void main(String[] args){
         Scanner input=new Scanner(System.in);
         System.out.print("Enter number of disks:");
         int n=input.nextInt();
         System.out.println("The moves are:");
         moveDisks(n,'A','B','C');
     }
     private static void moveDisks(int n,char fromTower,char toTower,char auxTower){
         if(n==1)
         System.out.println("Move disk "+n+" from "+fromTower+" to "+toTower);
         else{
             moveDisks(n-1,fromTower,auxTower,toTower);
             System.out.println("Move disk "+n+" from "+fromTower+" to "+toTower);
             moveDisks(n-1,auxTower, toTower,fromTower);
             
         }
         
     }
   
 }

3.八皇后问题

import java.awt.*;
import javax.swing.*;
public class EightQueens extends JApplet{
    /**
     * 
     */
    private static final long serialVersionUID = 5660619297259886927L;
    public  static final int SIZE=8;
    private int[] queens=new int[SIZE];
    
    public EightQueens(){
        search(0);
        add(new ChessBord(),BorderLayout.CENTER);
    }
    
    private boolean isValid(int row,int cloumn){
         for(int i=1;i<=row;i++){
             if(queens[row-i]==cloumn
             ||queens[row-i]==cloumn-1
             ||queens[row-i]==cloumn+1)
             
             return false;
         }
         return true;
    }
    
    private boolean search(int row){
        if(row==SIZE)
        return true;
        
        for(int cloumn=0;cloumn<SIZE;cloumn++){
            queens[row]=cloumn;
            if(isValid(row,cloumn)&&search(row+1))
            return true;
        }
        
        return false;
    }
    
    class ChessBord extends JPanel{
        /**
         * 
         */
        private static final long serialVersionUID = 4151757353625344600L;
        private Image queenImage=new ImageIcon("image/queen.jpg").getImage();
        
        ChessBord(){
            this.setBorder(BorderFactory.createLineBorder(Color.BLACK,2));
        }
        protected void paintComponent(Graphics g){
            super.paintComponent(g);
            
            //Paint the queens
            for(int i=0;i<SIZE;i++){
                int j=queens[i];
                g.drawImage(queenImage,j*getWidth()/SIZE,i*getHeight()/SIZE,getWidth()/SIZE,getHeight()/SIZE,this);
            }
            
            //Draw the horizontal and vertical lines
             for(int i=0;i<SIZE;i++){
                 g.drawLine(0,i*getHeight()/SIZE,getWidth(),i*getHeight()/SIZE);
                 g.drawLine(i*getWidth()/SIZE,0,i*getWidth()/SIZE,getHeight());
             }
            
        }
    }
}