一、递归算法的效率分析

我们以斐波那契数列递归函数的执行效率为例来讨论递归算法的执行效率问题。
斐波那契数列Fib(n)的递推定义是：

fib(5)的递归调用树：

二、递归算法转换为非递归算法

一般来说，如下两种情况的递归算法可转化为非递归算法：
（1）存在不借助堆栈的循环结构的非递归算法，如阶乘计算问题、斐波那契数列的计算问题、折半查找问题等
（2）存在借助堆栈的循环结构的非递归算法。所有递归算法都可以借助堆栈转换成循环结构的非递归算法。

实例：将求n的阶乘的递归算法转换为使用循环的非递归算法实现。

import java.util.Scanner;
//n!非递归实现（采用循环）
public class NoRecursion {
	public static long noRecursion(int n) {
		long result=1;
		for (int i = n; i >0; i--) {
			result*=i;
		}
		return result;
	}
	
	public static void main(String[] args) {

		Scanner sc=new Scanner(System.in);
		System.out.println("请输入一个整数");
		while(sc.hasNext()) {
			int n=sc.nextInt();
			long result=noRecursion(n);
			System.out.println(n+"！="+result);
		}
	}
}

回溯法的基本思想是：对一个包括有很多结点，每个结点有若干个搜索分支的问题，把原问题分解为对若干个子问题求解的算法。当搜索到某个结点、发现无法再继续搜索下去时，就让搜索过程回溯（即退回）到该结点的前一结点，继续搜索这个结点的其他尚未搜索过的分支；如果发现这个结点也无法再继续搜索下去时，就让搜索过程回溯到这个结点的前一结点继续这样的搜索过程；这样的搜索过程一直进行到搜索到问题的解或搜索完了全部可搜索分支没有解存在为止。

扫描二维码关注公众号，回复： 1601544 查看本文章

迷宫算法求解：

代码：

//回溯思想，来解决迷宫问题
public class MyMaze {

	private static int startPosI;
	private static int startPosJ;
	private static int endPosI;
	private static int endPosJ;
	
	//设置入口
	public void setStart(int startPosI,int startPosJ) {
		MyMaze.startPosI=startPosI;
		MyMaze.startPosJ=startPosJ;
	}
	
	//设置出口
	public void setEnd(int endPosI,int endPosJ) {
		MyMaze.endPosI=endPosI;
		MyMaze.endPosJ=endPosJ;
	}
	
	public static void visited(int cell[][],int i,int j) {
		cell[i][j]=1;
		//表示找到了出口
		if(i==endPosI&&j==endPosJ) {
			System.out.println("找到了一条通路...........");
			for (int m = 0; m < cell.length; m++) {
				for (int n = 0; n < cell[0].length; n++) {
					if(cell[m][n]==2)
						System.out.print("2");
					else if(cell[m][n]==1)
						System.out.print("*");
					else
						System.out.print(" ");
				}
				System.out.println();
			}
		}
		//向左找
		if(cell[i][j-1]==0)
			visited(cell, i, j-1);
		
		//向右找
		if(cell[i][j+1]==0)
			visited(cell, i, j+1);
		
		//向上找
		if(cell[i-1][j]==0)
			visited(cell, i-1, j);
		
		//向下找
		if(cell[i+1][j]==0)
			visited(cell, i+1, j);
		
		cell[i][j]=0;
	}
	
	public static void main(String[] args) {
		int maze[][]= {
			{2,2,2,2,2,2,2,2,2},
			{2,0,0,0,0,0,0,0,2}, 
			{2,0,2,2,0,2,2,0,2}, 
			{2,0,2,0,0,2,0,0,2},
			{2,0,2,0,2,0,2,0,2}, 
			{2,0,0,0,0,0,2,0,2}, 
			{2,2,0,2,2,0,2,2,2}, 
			{2,0,0,0,0,0,0,0,2}, 
			{2,2,2,2,2,2,2,2,2}
		};
		MyMaze cell=new MyMaze();
		cell.setStart(1, 1);
		cell.setEnd(7, 7);
		MyMaze.visited(maze, 1, 1);
				
	}
}

结果：