递归

 

关于递归的一些杂感

递归是一种重要的编程技术。该方法用于让一个函数从其内部调用其自身。递归适合于解决需要反复循环的业务流程，每循环一次，任务就减少一个回合。当前正在运行的函数只管解决一个回合的问题，其他的调用再由这个函数解决，只是传递的参数是下一个回合所要的参数，当前含数的一个重要任务就是找出下一次调用的参数。

下面是用递归的编写的例子

1．  求一个整数N的阶乘

算法思想：由于 N!=N*(N-1)*(N-2)*…*2*1，我们可以这样来思考：N！=N*（N-1）！，我们只要求出N*（N-1）！问题就解决了，而（N-1）！=N*（N-2）！，依次类推。我们只管第一回合，至于（N-1）！等于多少就是递归函数的事了。

源代码：

long fun(int n)  
   
   

{
  
  

if (n < 0)  
   
   

{  
  
  

    return -1;
  
  

 }
  
  

 if (n == 0)  
   
   

{ 
   
   

     return 1;
  
  

}
  
  

 else return (n * fun(n - 1));  
  
  

}
  
  

 

2．  求两个数的最大公约数

算法思想：12 与 3，

12-3 = 9    9 != 3   12 > 9 > 3 舍掉最大的

9-3 = 6     6 != 3    9 > 6 > 3

6-3 = 3     3 == 3   3就是要求的最大公约数

源代码：

public static void yueshu(int num1,int num2)

       {

              if (num1==num2)

              {

                     System.out.println(num1);

              }

              else

              {

                     yueshu(abs(num1-num2),min(num1,num2));

              }

       }    

3.汉诺塔

算法思想：将N个盘子从A盘移动到C盘可分解为下面三个步骤:

1.     将A上的N-1个盘子借助于C盘移到B盘上;

2.     将A上剩下的一个盘子移到C盘;

3.     将N-1个盘子借助于A盘从B移到C盘.

事实上,上面的三个步骤包含两种操作:

1将多个盘子从一个盘子上移动到另一个盘子上,这是一个递归过程.用hanno()方法实现

2将一个盘子从一个盘子移动到另一个盘子上,用move()方法实现

源代码：

public static void hanon(int n,char a,char b,char c)

     {    

            if(n == 1)

            {

                   move(1,a,c);

                   return;

            }

            hanon(n-1,a,c,b);

            move(n,a,c);

            hanon(n-1,b,a,c);

     }

 

4.利用递归编写Windows 的Tree命令

算法思想：如果列表中一个目录或文件有弟弟，那么它前面加“├─”，否则，它前面加“└─”，如果是根元素，那么前面什么也不加。如果它的父级没有弟弟，则在父级上补“    ”，否则，在父级上补“│  ”。如果父级没有父级，即父级为整个元素的根，则什么也不补，且结束结束递归调用。

源代码：

import java.io.File;
class MainClass
{
 public static void main(String [] args)
  {
   String strFile = ".";
   if(args.length != 0)
   {
    strFile = args[0];
   }
 
   File fFile = new File(strFile);
    new FileWrapper(fFile,false,null).display();
 
  }
 
 }

class FileWrapper extends File
{
  boolean bLast = false;
  FileWrapper parent = null;
 public boolean isLast()
 {
     return bLast;
 }
 
 public FileWrapper getParentWrapper()
 {
  return parent;
 }
 
  public FileWrapper(File f,boolean bLast,FileWrapper parent)
  {
   super(f.getPath());
   this.bLast = bLast;
   this.parent = parent;
  }
 
  private String makePrefix()
  {
   StringBuffer sbf = new StringBuffer();
   if(parent == null)
   {
    return "";
   }
  
   if(bLast)
   {
    sbf.append("─└");
   }
   else
   {
    sbf.append("─├");
   }
  
   makeParentPrefix(parent,sbf);
   sbf.reverse();
   return sbf.toString();
 }
 
 private void makeParentPrefix(FileWrapper parent,StringBuffer sbf)
 {
   if(parent.getParentWrapper() != null)
   {
     if(parent.isLast())
     {
      sbf.append("    ");
     }
     else
     {
      sbf.append("  │");
     }
     makeParentPrefix(parent.getParentWrapper(),sbf);
   }
  }
 
  public void display()
  {
   System.out.println(makePrefix() +getName());
   if(this.isDirectory())
   {
     File [] subFiles = this.listFiles();
     for(int i=0;i<subFiles.length;i++)
     {
      if(i < subFiles.length-1)
      {
        new FileWrapper(subFiles[i],false,this).display();
      }
      else
      {
        new FileWrapper(subFiles[i],true,this).display();
      }
     }
   }
  }
}

运行结果如图所示：