1. 全栈程序员必看首页

数据结构JAVA—递归算法「建议收藏」

全栈程序员-用户IM • • 未分类

数据结构JAVA—递归算法「建议收藏」http://blog.csdn.net/wangjinyu501/article/details/8248492  原版一、基本概念       递归算法是一种直接或者间接调用自身函数或者方法的算法。Java递归算法是基于Java语言实现的递归算法。递归算法的实质是把问题分解成规模缩小的同类问题的子问题，然后递归调用方法来表示问题的解。递归算法对解决

大家好，又见面了，我是你们的朋友全栈君。

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


一、基本概念

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

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

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

   二、程序示例

      ①斐波纳契数列（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 plain
copy

  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 plain
copy

  1. if(index==1 || index==2){   
  2.           return 1;   
  3. }    

    
这个代码段上，如果程序的index符合条件就会停止进行递归。所以这个程序的运行流程是：

                        数据结构JAVA---递归算法「建议收藏」

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

      ②n的阶乘

            问题描述：求5的阶乘

             求解代码：

[java] 
view plain
copy

  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. }  

       程序执行流程如下：

                                     数据结构JAVA---递归算法「建议收藏」

          ③列出某个目录下所有的子目录和文件

   求解代码：

[html] 
view plain
copy

  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 plain
copy

  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进栈
　　}
　　}
　　间接转换法在数据结构中有较多实例，如二叉树遍历算法的非递归实现、图的深度优先遍历算法的非递归实现等等，请读者参考主教材中相关内容。


版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 举报，一经查实，本站将立刻删除。

发布者：全栈程序员-用户IM，转载请注明出处：https://javaforall.cn/156825.html原文链接：https://javaforall.cn

【正版授权，激活自己账号】： Jetbrains全家桶Ide使用，1年售后保障，每天仅需1毛

【官方授权 正版激活】： 官方授权 正版激活 支持Jetbrains家族下所有IDE 使用个人JB账号...

赞 (0)
全栈程序员-用户IM全栈程序员-用户IM
0 0
blank

相关推荐

发表回复

您的电子邮箱地址不会被公开。

关注全栈程序员社区公众号