首页 > 编程语言 > 详细

递归算法

时间：2015-01-04 18:31:52      阅读：279      评论：0      收藏：0      [点我收藏+]

http://blog.csdn.net/wangjinyu501/article/details/8248492  原版


一、基本概念

            递归算法是一种直接或者间接调用自身函数或者方法的算法。Java递归算法是基于Java语言实现的递归算法。递归算法的实质是把问题分解成规模缩小的同类问题的子问题，然后递归调用方法来表示问题的解。递归算法对解决一大类问题非常有效，它能够使算法简洁和易于理解。递归算法，事实上说白了，就是程序的自身调用。它表如今一段程序中往往会遇到调用自身的那样一种coding策略，这样我们就能够利用大道至简的思想，把一个大的复杂的问题层层转换为一个小的和原问题相似的问题来求解的这样一种策略。递归往往能给我们带来非常简洁非常直观的代码形势，从而使我们的编码大大简化，然而递归的思维确实非常我们的常规思维相逆的，我们通常都是从上而下的思维问题， 而递归趋势从下往上的进行思维。这样我们就能看到我们会用很少的语句攻克了很大的问题，所以递归策略的最主要体现就是小的代码量攻克了很复杂的问题。

            递归算法解决这个问题的特点：   
             1）递归就是方法里调用自身。   
             2）在使用递增归策略时，必须有一个明白的递归结束条件，称为递归出口。    
             3）递归算法解题通常显得非常简洁，但递归算法解题的执行效率较低。所以一般不提倡用递归算法设计程序。
             4）在递归调用的过程其中系统为每一层的返回点、局部量等开辟了栈来存储。递归次数过多easy造成栈溢出等，所以一般不提倡用递归算法设计程序。

             在做递归算法的时候，一定要把握住出口，也就是做递归算法必需要有一个明白的递归结束条件。这一点是很重要的。事实上这个出口是很好理解的，就是一个条件，当满足了这个条件的时候我们就不再递归了。

   二、程序演示样例

      ①斐波纳契数列（Fibonacci Sequence）

              问题描写叙述：求解Fibonacci数列的第n个位置的值？（斐波纳契数列（Fibonacci Sequence），又称黄金切割数列，指的是这样一个数列：1、1、2、3、5、8、13、21、……在数学上，斐波纳契数列以例如以下被以递归的方法定义：F1=1,F2=1,Fn=F（n-1）+F（n-2）（n>2,n∈N*））。

              求解代码：

[java] view plaincopy
  1. public class Fibonacci {  
  2.     /** 
  3.      * time:2012.12.2 
  4.      * author:王金宇 
  5.      * description:用递归实现斐波那契数列，可是此方法是妒忌危急的，适用于求解比較小的位置数值 
  6.      */  
  7.     public static void main(String[] args) {  
  8.         Fibonacci fibonacci=new Fibonacci();  
  9.         int result=fibonacci.fib(5);  
  10.                System.out.println(result);  
  11.     }  
  12.   
  13.     public int fib(int index){  
  14.         if(index==1||index==2){  
  15.             return 1;  
  16.         }else{  
  17.             return fib(index-1)+fib(index-2);  
  18.         }  
  19.     }  
  20. }  
         程序分析：这个实例是很经典的实例，主要是利用递归实现了Fibonacci数列。这个递归算法的出口是在
[java] view plaincopy
  1. if(index==1 || index==2){   
  2.           return 1;   
  3. }    
    这个代码段上，假设程序的index符合条件就会停止进行递归。所以这个程序的执行流程是：

                        技术分享

          刚才说了这种方法十几度危急的，为什么这么说，原因在于在这个递归里做了冗余的工作，如图，我们在f4里面已经计算了f2，但是f3里有相同计算了f2，以此类推那些冗余的工作，在数值比較小的情况下，计算机还是能够接受的。但是，当求解的数值比較大，它是成指数级增长的，所以不要再递归中做反复的工作。

      ②n的阶乘

            问题描写叙述：求5的阶乘

             求解代码：

[java] view plaincopy
  1. public class Factorial_Five {  
  2.   
  3.     /** 
  4.      * time:2012.12.2 
  5.      * author:王金宇 
  6.      * description:递归求n的阶乘 
  7.      */  
  8.     public static void main(String[] args) {  
  9.         Factorial_Five factorial_Five=new Factorial_Five();  
  10.         int result=factorial_Five.factorial(5);  
  11.         System.out.println(result);  
  12.     }  
  13.     public int factorial(int index){  
  14.         if(index==1){  
  15.         return 1;  
  16.         }else{  
  17.         return factorial(index-1)*index;  
  18.         }  
  19.     }  
  20.   
  21. }  
       程序运行流程例如以下：

                                     技术分享

          ③列出某个文件夹下全部的子文件夹和文件

   求解代码：
[html] view plaincopy
  1. /*  
  2.  * time:2012.12.2  
  3.  * author:王金宇  
  4.  * description：列出某个文件夹下全部的子文件夹和文件  
  5.  */  
  6. public class ListDir {  
  7.     static void getDir(String strPath) throws Exception {  
  8.         try {  
  9.             File f = new File(strPath);  
  10.             if (f.isDirectory()) {  
  11.                 File[] fList = f.listFiles();  
  12.                 for (int j = 0; j < fList.length; j++) {  
  13.                     if (fList[j].isDirectory()) {  
  14.                         System.out.println(fList[j].getPath());  
  15.                         getDir(fList[j].getPath()); // 在getDir函数里面又调用了getDir函数本身  
  16.                     }  
  17.                 }  
  18.                 for (int j = 0; j < fList.length; j++) {  
  19.   
  20.                     if (fList[j].isFile()) {  
  21.                         System.out.println(fList[j].getPath());  
  22.                     }  
  23.                 }  
  24.             }  
  25.         } catch (Exception e) {  
  26.             System.out.println("Error： " + e);  
  27.         }  
  28.   
  29.     }  
  30.     public static void main(String[] args) {  
  31.         String strPath = "E:";  
  32.         System.out.println(strPath);  
  33.         try {  
  34.             getDir(strPath);  
  35.         } catch (Exception e) {  
  36.         }  
  37.     }  
  38. }  
       这个流程图你懂得，看文件数目了，大家自己分析吧。
 ④汉诺塔问题
   这是递归的超经典的样例，差点儿每本程序设计书上谈到递归都会介绍。详细情景不再赘述。以我上述的方法观之：
    （1）递归的出口在于盘子数为1的时候 。

　　（2）向出口逼近：假设不是1，是n ，则我们先挪动上面n-1块盘子，等上面挪完，即递归返回的时候，我们挪动最底下的盘子。

　　 求解代码：

[html] view plaincopy
  1. import javax.swing.JOptionPane;  
  2. /*  
  3.  * time:2012.12.2  
  4.  * author:王金宇  
  5.  * description:  
  6.  */  
  7. public class Hanoi {  
  8.     private final static String from = "盘子B";  
  9.     private final static String to = "盘子C";  
  10.     private final static String mid = "盘子A";  
  11.   
  12.     public static void main(String[] args) {  
  13.         String input = JOptionPane.showInputDialog("请输入你要移动的盘子数");  
  14.         int num = Integer.parseInt(input);  
  15.         Hanoi.move(num, from, mid, to);  
  16.     }  
  17.     private static void move(int num, String from2, String mid2, String to2) {  
  18.         if (num == 1) {  
  19.             System.out.println("移动盘子1 从" + from2 + "到" + to2);  
  20.         } else {  
  21.             move(num - 1, from2, to2, mid2);  
  22.             System.out.println("移动盘子" + num + " 从" + from2 + "到" + to2);  
  23.             move(num - 1, mid2, from2, to2);  
  24.   
  25.         }  
  26.   
  27.     }  
  28.   
  29. }  
    由于汉诺塔的移动过程比較复杂，用图片来表示是不现实的，我找到了一个用视频做的显示汉诺塔移动过程的实例，大家能够下载用浏览器打开：http://v.youku.com/v_show/id_XMzgzOTEzNjMy.html
    还有非常多的递归的样例，我会继续更新。


三、递归算法转换成非递归算法

             递归算法实际上是一种分而治之的方法，它把复杂问题分解为简单问题来求解。对于某些复杂问题(比如hanio塔问题)，递归算法是一种自然且合乎逻辑的解决这个问题的方式，可是递归算法的运行效率通常比較差。因此，在求解某些问题时，常採用递归算法来分析问题，用非递归算法来求解问题；另外，有些程序设计语言不支持递归，这就须要把递归算法转换为非递归算法。将递归算法转换为非递归算法有两种方法，一种是直接求值，不须要回溯；还有一种是不能直接求值，须要回溯。前者使用一些变量保存中间结果，称为直接转换法；后者使用栈保存中间结果，称为间接转换法，以下分别讨论这两种方法。
　　
  1. 直接转换法
　　直接转换法通经常使用来消除尾递归和单向递归，将递归结构用循环结构来替代。尾递归是指在递归算法中，递归调用语句仅仅有一个，并且是处在算法的最后。比如求阶乘的递归算法：
　public  long fact(int n)
　　{
　　if (n==0) return 1;
　　else return n*fact(n-1);
　　}
　　当递归调用返回时，是返回到上一层递归调用的下一条语句，而这个返回位置正好是算法的结束处，所以
，不必利用栈来保存返回信息。对于尾递归形式的递归算法，能够利用循环结构来替代。比如求阶乘的递归算法
能够写成例如以下循环结构的非递归算法：
　　public long fact(int n)
　　{
　　int s=0;
　　for (int i=1; i
　　s=s*i; //用s保存中间结果
　　return s;
　　}
　　单向递归是指递归算法中尽管有多处递归调用语句，但各递归调用语句的參数之间没有关系，而且这些递归
调用语句都处在递归算法的最后。显然，尾递归是单向递归的特例。比如求斐波那契数列的递归算法例如以下：
　　public int f(int n)
　　{
　　if (n= =1 | | n= =0) return 1;
　　else return f(n-1)+f(n-2);
　　}
　　对于单向递归，能够设置一些变量保存中间结构，将递归结构用循环结构来替代。比如求斐波那契数列的算
法中用s1和s2保存中间的计算结果，非递归函数例如以下：
　　public int f(int n)
　　{
　　int i, s;
　　int s1=1, s2=1;
　　for (i=3; i {
　　s=s1+s2;
　　s2=s1; // 保存f(n-2)的值
　　s1=s; //保存f(n-1)的值
　　}
　　return s;
　　}
　　2. 间接转换法
　　该方法使用栈保存中间结果，一般需依据递归函数在运行过程中栈的变化得到。其一般步骤例如以下：
　　将初始状态s0进栈
　　while (栈不为空)
　　{
　　退栈，将栈顶元素赋给s;
　　if (s是要找的结果) 返回;
　　else {
　　寻找到s的相关状态s1;
　　将s1进栈
　　}
　　}
　　间接转换法在数据结构中有较多实例，如二叉树遍历算法的非递归实现、图的深度优先遍历算法的非递归实现等等，请读者參考主教材中相关内容。


递归算法

原文：http://www.cnblogs.com/gcczhongduan/p/4201473.html
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
分享档案
更多>
2021年09月23日 (328)
2021年09月24日 (313)
2021年09月17日 (191)
2021年09月15日 (369)
2021年09月16日 (411)
2021年09月13日 (439)
2021年09月11日 (398)
2021年09月12日 (393)
2021年09月10日 (160)
2021年09月08日 (222)
最新文章
更多>
教程昨日排行
更多>
友情链接
汇智网   PHP教程   插件网  
关于我们 - 联系我们 - 留言反馈 - 联系我们:wmxa8@hotmail.com
© 2014 bubuko.com 版权所有
打开技术之扣，分享程序人生！