浅谈如何写递归函数

浅谈如何写递归函数

写过一些递归函数，发现一些规律，分享一下吧，欢迎大神指教

编写递归函数总结

1.明确递归函数的参数列表，确定数据的存储方式

2.确定递归函数的结束条件，以及应该采取的方法，这些条件一般都放在函数的开头处，用于判断是否结束递归，很重要

3.找到递归的循环体，就是将那些会反复执行的语句找出来，

4.将循环体写在递归结束条件后面

5.over

下面就以一些例子来谈谈

以Java为下面的程序语言

一.汉诺塔问题，虽然都被讲烂了，但还是说一说

1.明确参数列表

汉诺塔这个问题的参数列表比较好找

参数：

碟子数 n

三个柱子的标记，分别标记为 A B C

那用什么数据类型呢？

当然是int 和char了

2.结束条件以及采取的方法

汉诺塔结束的条件就是当一个柱子上的碟子数为1时结束

结束时直接打印一条输出语句就行，就是将这个碟子移到目的柱子

3.怎么找循环体

汉诺塔的循环体就是

你要想将n个碟子从A移到C，

那必须先将n-1个碟子从A移到B，

再将一个碟子从A移到C，

然后将n-1个碟子从B移到C

你要想将n-1个盘子从A移到B.......后面就循环了

4接下来就是代码了

public class hannuo
{
	static int count;//统计总次数
	public static void main(String[] args)
	{
		HN(10,'A','B','C');
		System.out.println("总移动次数为："+count);
	}
	public static void HN(int n,char begin,char mid,char end)
	{
		if(n==1)
		{
			System.out.println("将碟子从"+begin+"移到--------->"+end);
			count++;
			return;
		}
		HN(n-1,begin,end,mid);
		System.out.println("将碟子从"+begin+"移到--------->"+end);
		count++;
		HN(n-1,mid,begin,end);
	}
}

下面还有一个走迷宫的代码，也是用递归写的，基本上也是按照上面这个套路写的

上代码

//import java.util.*;
public class Maze
{
	static int MAX_ROW=10;
	static int MAX_COLUMN=10;
	static boolean flag=false;
	public static void main(String[] args)
	{
		int[][] arr=new int[][]{
			{1,1,0,0,0,0,0,0,0,0},
			{0,1,1,1,1,1,1,1,0,0},
			{0,0,0,1,0,0,0,1,0,0},
			{0,0,0,1,1,1,0,1,0,0},
			{0,0,0,0,0,1,0,1,1,1},
			{1,1,1,0,0,1,0,0,0,1},
			{1,0,1,0,1,1,0,0,0,1},
			{1,0,1,1,1,0,1,1,1,1},
			{1,0,0,0,0,0,0,0,0,0},
			{1,1,1,1,1,1,1,1,1,1}

		};
		int[] beginCoordinate={0,0};//第一个表示行，第二个表示列
		int[] endCoordinate={9,9};
		System.out.println("一开始的迷宫，1代表有路，0代表没路");
		System.out.println("\n\n起始坐标("+beginCoordinate[0]+","+beginCoordinate[1]+")"+"           结束坐标("+endCoordinate[0]+","+endCoordinate[1]+")");
		printarr(arr);
		solve(arr,beginCoordinate[0],beginCoordinate[1],endCoordinate);
		if(!flag)
		System.out.print("没有找到走出迷宫的路");
	}
	



	public static void solve(int[][] arr,int row,int column,int[] endCoordinate)
	{
		//判断是否到达了终点
		if(row==endCoordinate[0] && column==endCoordinate[1])
		{
			flag=true;//找到了出口，将flag改为true
			System.out.println("走出迷宫的路为");
			printarr(arr);
			return;
		}

		//判断是否不能继续走下去
		if(check(arr,row,column))
		{
			arr[row][column]=-2;//将错误的路线上的数变成-2
			int[] re=getReturn(arr,row,column);
			row=re[0];
			column=re[1];
			solve(arr,row,column,endCoordinate);
			return;
		}

		//如果当前行的下一格满足条件，向下一格走
		if(column+1<MAX_COLUMN && row <=MAX_ROW && arr[row][column+1]==1)
		{
			arr[row][column+1]=7;
			solve(arr,row,column+1,endCoordinate);
		}

		//如果当前列的下一格满足条件，向下一格走
		if(column<MAX_COLUMN && row+1<MAX_ROW && arr[row+1][column]==1)
		{
			arr[row+1][column]=7;
			solve(arr,row+1,column,endCoordinate);
		}
		//如果当前行的前一格满足条件，向前走
		if(column-1>=0 && row<MAX_ROW && arr[row][column-1]==1)
		{
			arr[row][column-1]=7;
			solve(arr,row,column-1,endCoordinate);
		}
		//如果当前列的上一格满足条件，向上走
		if(row-1>=0 && column<MAX_COLUMN && arr[row-1][column]==1)
		{
			arr[row-1][column]=7;
			solve(arr,row-1,column,endCoordinate);
		}
		
	}
	


//检查是否没路了
	public static boolean check(int[][] arr,int row,int column)
	{
		if(row==0 && column==0)
			return false;
		int count=0;
		if(check(row-1,column,arr))
			count++;
		if(check(row+1,column,arr))
			count++;
		if(check(row,column+1,arr))
			count++;
		if(check(row,column-1,arr))
			count++;
		if(count==1)
			return true;
		return false;
	}
	


//检查当前格子周围的格子是否满足条件
	public static boolean check(int row,int column,int[][] arr)
	{
		if(row<0 || row>=MAX_ROW|| column<0 || column>=MAX_COLUMN)
			return false;
		if(arr[row][column]>0)
			return true;
		return false;
	}
	


//输出二维数组
	public static void printarr(int[][] arr)
	{
		System.out.println("|------------------------------------------------------->x轴");
		
		for(int[] ss:arr)
		{
			System.out.print("| ");
			for(int dd:ss)
		{
			System.out.print(dd+"\t");
		}
		System.out.println("");
		}
		for(int i=0;i<4;i++)
			System.out.println("| ");
		System.out.println("y轴");
	}



//当没路时，通过这个方法获得自己上一个的格子的行和列
	public static int[] getReturn(int[][] arr,int row,int column)
	{
		int[] re=new int[2];
		if(check(row-1,column,arr))
		{
			re[0]=row-1;
			re[1]=column;
			return re;
		}
		if(check(row+1,column,arr))
		{
			re[0]=row+1;
			re[1]=column;
			return re;
		}
		if(check(row,column+1,arr))
		{
			re[0]=row;
			re[1]=column+1;
			return re;
		}
		if(check(row,column-1,arr))
		{
			re[0]=row;
			re[1]=column-1;
			return re;
		}
		return re;
	}
}

写的不好别喷我