Java數據結構與算法 day04 遞歸

第五章 遞歸

本章源碼:https://github.com/name365/Java-Data-structure

遞歸應用場景和調用機制

遞歸的應用場景

先看個實際應用場景,迷宮問題(回溯),遞歸(Recursion)

在這裏插入圖片描述

遞歸的概念

簡單的說: 遞歸就是方法自己調用自己,每次調用時傳入不同的變量.遞歸有助於編程者解決複雜的問題,同時可以讓代碼變得簡潔。

遞歸調用機制

列舉兩個小案例,回顧一下遞歸調用機制

1)打印問題

2)階乘問題

遞歸調用規則:

  1. 當程序執行到一個方法時,就會開闢一個獨立的空間(棧)

  2. 每個空間的數據(局部變量),是獨立的.

在這裏插入圖片描述

在這裏插入圖片描述
在這裏插入圖片描述
在這裏插入圖片描述
在這裏插入圖片描述
在這裏插入圖片描述
在這裏插入圖片描述
在這裏插入圖片描述
在這裏插入圖片描述
在這裏插入圖片描述

public class RunTest {

	public static void main(String[] args) {
		//打印問題,遞歸調用
		test(4);
		
		//階乘問題,遞歸方法
		int res = factorial(2);
		System.out.println("res = " + res);
	}

	//打印問題
	public static void test(int n) {
		if (n > 2) {
			test(n - 1);
		} //else{			
			System.out.println("n=" + n);
		//}
	}
	
	//階乘
	public static int factorial(int n) {
		if (n == 1) {
			return 1;
		} else {
			return factorial(n - 1) * n;
		}
	}

}

遞歸能解決的問題和規則

遞歸能幹什麼????

  1. 各種數學問題如: 8皇后問題 , 漢諾塔, 階乘問題, 迷宮問題, 球和籃子的問題(google編程大賽)

  2. 各種算法中也會使用到遞歸,比如快排,歸併排序,二分查找,分治算法等.

  3. 將用棧解決的問題–>第歸代碼比較簡潔

運用遞歸需要遵守那些規則???

1. 執行一個方法時,就創建一個新的受保護的獨立空間(棧空間)
2. 方法的局部變量是獨立的,不會相互影響, 比如n變量
3. 如果方法中使用的是引用類型變量(比如數組),就會共享該引用類型的數據.
4. 遞歸必須向退出遞歸的條件逼近,否則就是無限遞歸,出現StackOverflowError,死龜了:)
5. 當一個方法執行完畢,或者遇到return,就會返回,遵守誰調用,就將結果返回給誰,同時當方法執行完畢或者返回時,該方法也就執行完畢。

迷宮回溯問題分析和實現

遞歸-迷宮問題

在這裏插入圖片描述

說明: 
1.小球得到的路徑,和程序員設置的找路策略有關即:找路的上下左右的順序相關
2.再得到小球路徑時,可以先使用(下右上左),再改成(上右下左),看看路徑是不是有變化
3.測試回溯現象
4.思考: 如何求出最短路徑? 
    
代碼實現如下:    
public class MaGo {

	public static void main(String[] args) {
		//先創建一個二維數組,用於模擬迷宮
		//地圖
		int[][] map = new int[8][7];
		//使用1表示
		//上下全置爲1
		for(int i = 0;i <7 ;i++){
			map[0][i] = 1;
			map[7][i] = 1;
		}
		//左右全置爲1
		for(int i = 0;i < 8;i++){
			map[i][0] = 1;
			map[i][6] = 1;
		}
		//設置擋板,1表示
		map[3][1] = 1;
		map[3][2] = 1;
		//輸出地圖
		System.out.println("地圖的初始情況:");
		for(int i = 0;i < 8;i++){
			for(int j = 0;j < 7;j++){
				System.out.print(map[i][j] + " ");
			}
			System.out.println();
		}
		
		//使用遞歸回溯給小球找路
		setWay(map, 1, 1);
				
		//輸出新的地圖, 小球走過,並標識過的遞歸
		System.out.println("小球走過,並標識走過的地圖的情況:");
		for(int i = 0;i < 8;i++){
			for(int j = 0;j < 7;j++){
				System.out.print(map[i][j] + " ");
			}
			System.out.println();
		}
	}

	/**
	  * 
	  * @Description 使用遞歸來給小球找路
	  * @author subei
	  * @date 2020年5月28日上午9:52:07
	  * @param map 表示地圖
	  * @param i 從哪個位置開始找
	  * @param j
	  * @return 如果找到通路,就返回true, 否則返回false
	 */
	//詳細說明
	//1.map 表示地圖
	//2.i,j 表示從地圖的哪個位置開始出發 (1,1)
	//3.如果小球能到 map[6][5] 位置,則說明通路找到.
	//4.約定: 當map[i][j] 爲 0 表示該點沒有走過 當爲 1 表示牆 ;2 表示通路可以走 ; 3 表示該點已經走過,但是走不通
	//5.在走迷宮時,需要確定一個策略(方法) 下->右->上->左 , 如果該點走不通,再回溯
	public static boolean setWay(int[][] map,int i,int j){
		if(map[6][5] == 2){	//通路已經找到
			return true;
		}else{
			if(map[i][j] == 0){	//如果當前的點未走過
				//按步驟做 下->右->上->左  走
				map[i][j] = 2;	//假設此點可以通向終點
				if(setWay(map, i+1, j)) {	//先向下走
					return true;
				} else if (setWay(map, i, j+1)) { //再向右走
					return true;
				} else if(setWay(map, i-1, j)) { //再向上
					return true;
				} else if (setWay(map, i, j-1)){ //再向左走
					return true;
				} else {
					//最後說明該點是無法通向終點,pass
					map[i][j] = 3;
					return false;
				}
			}else{	//如果map[i][j] != 0 , 可能是 1, 2, 3
				return false;
			}
		}
	}
}

另一種方法:

public class MaGo2 {

	public static void main(String[] args) {
		//先創建一個二維數組,用於模擬迷宮
		//地圖
		int[][] map = new int[8][7];
		//使用1表示
		//上下全置爲1
		for(int i = 0;i <7 ;i++){
			map[0][i] = 1;
			map[7][i] = 1;
		}
		//左右全置爲1
		for(int i = 0;i < 8;i++){
			map[i][0] = 1;
			map[i][6] = 1;
		}
		//設置擋板,1表示
		map[3][1] = 1;
		map[3][2] = 1;
		//輸出地圖
		System.out.println("地圖的初始情況:");
		for(int i = 0;i < 8;i++){
			for(int j = 0;j < 7;j++){
				System.out.print(map[i][j] + " ");
			}
			System.out.println();
		}
		
		//使用遞歸回溯給小球找路
		setWay2(map, 1, 1);
				
		//輸出新的地圖, 小球走過,並標識過的遞歸
		System.out.println("小球走過,並標識走過的地圖的情況:");
		for(int i = 0;i < 8;i++){
			for(int j = 0;j < 7;j++){
				System.out.print(map[i][j] + " ");
			}
			System.out.println();
		}
	}

	/**
	  * 
	  * @Description 使用遞歸來給小球找路
	  * @author subei
	  * @date 2020年5月28日上午9:52:07
	  * @param map 表示地圖
	  * @param i 從哪個位置開始找
	  * @param j
	  * @return 如果找到通路,就返回true, 否則返回false
	 */
	//修改找路策略,改爲 上 --》 右 --》 下 --》 左
	public static boolean setWay2(int[][] map,int i,int j){
		if(map[6][5] == 2){	//通路已經找到
			return true;
		}else{
			if(map[i][j] == 0){	//如果當前的點未走過
				//按步驟做 上 --》 右 --》 下 --》 左 走
				map[i][j] = 2;	//假設此點可以通向終點
				if(setWay2(map, i-1, j)) {	//先向上走
					return true;
				} else if (setWay2(map, i, j+1)) { //再向右走
					return true;
				} else if(setWay2(map, i+1, j)) { //再向下
					return true;
				} else if (setWay2(map, i, j-1)){ //再向左走
					return true;
				} else {
					//最後說明該點是無法通向終點,pass
					map[i][j] = 3;
					return false;
				}
			}else{	//如果map[i][j] != 0 , 可能是 1, 2, 3
				return false;
			}
		}
	}
}

八皇后問題分析和實現

八皇后問題介紹

八皇后問題,是一個古老而著名的問題,是回溯算法的典型案例。該問題是國際西洋棋棋手馬克斯·貝瑟爾於1848年提出:在8×8格的國際象棋上擺放八個皇后,使其不能互相攻擊,即:任意兩個皇后都不能處於同一行、同一列或同一斜線上,問有多少種擺法 (92) 。

在這裏插入圖片描述
在這裏插入圖片描述

算法思路分析

1.第一個皇后先放第一行第一列
2.第二個皇后放在第二行第一列、然後判斷是否OK, 如果不OK,繼續放在第二列、第三列、依次把所有列都放完,找到一個合適
3.繼續第三個皇后,還是第一列、第二列……直到第8個皇后也能放在一個不衝突的位置,算是找到了一個正確解
4.當得到一個正確解時,在棧回退到上一個棧時,就會開始回溯,即將第一個皇后,放到第一列的所有正確解,全部得到.
5.然後回頭繼續第一個皇后放第二列,後面繼續循環執行 1,2,3,4的步驟 

說明:理論上應該創建一個二維數組來表示棋盤,但是實際上可以通過算法,用一個一維數組即可解決問題. arr[8] = {0 , 4, 7, 5, 2, 6, 1, 3} //對應arr 下標 表示第幾行,即第幾個皇后,arr[i] = val , val 表示第i+1個皇后,放在第i+1行的第val+1列

代碼實現如下:

public class Queue8 {

	// 定義一個max表示共有多少個皇后
	int max = 8;
	// 定義一個數組array,保存皇后的地址,如 arr = {0 , 4, 7, 5, 2, 6, 1, 3}
	int[] array = new int[max];
	static int count = 0; // 統計解法數目
	static int judgeCount = 0; // 統計衝突次數

	public static void main(String[] args) {
		// 具體測試:
		Queue8 Q8 = new Queue8();
		Q8.Qnum(0);
		System.out.printf("一共有%d解法", count);
		System.out.printf("一共判斷衝突的次數%d次", judgeCount);	//15720次
	}

	// 自定義一個方法,放置n個皇后
	// 注意: Qnum 是每一次遞歸時,進入到Qnum中都有 for(int i = 0; i < max; i++),因此會有回溯.
	public void Qnum(int n) {
		if (n == max) { // n = 8;等同於在放置第九個皇后,等同於結束
			print(); // 輸出結果
			return;
		}
		// 依次放入皇后,並進行相關判斷
		for (int i = 0; i < max; i++) {
			// 先把當前的皇后,放到該行的第1列
			array[n] = i;
			// 判斷當放置的第n個皇后到i列時,是否衝突
			if (judge(n)) { // 如果不衝突
				// 繼續放n+1個皇后,即開始遞歸
				Qnum(n + 1);
			}
			// 如果衝突,就繼續執行 array[n] = i; 即將第n個皇后,放置在本行的皇后,後移的一個位置
		}
	}

	// 定義一個方法,判斷放置的皇后之間是否產生衝突
	// n 表示第n個皇后
	private boolean judge(int n) {
		// 詳細說明
		// 1.array[i] == array[n] 表示判斷:第n個皇后是否和前面的n-1個皇后在同一列
		// 2.Math.abs(n-i) == Math.abs(array[n] - array[i])
		// 表示判斷:第n個皇后是否和第i皇后是否在同一斜線
		// n = 1 放置第 2列 1 n = 1 array[1] = 1
		// Math.abs(1-0) == 1 Math.abs(array[n] - array[i]) = Math.abs(1-0) = 1
		// 3.表示判斷:是否在同一行, 沒有必要,n 每次都在遞增
		judgeCount++;
		for (int i = 0; i < n; i++) {
			if (array[i] == array[n] || Math.abs(n - i) == Math.abs(array[n] - array[i])) {
				return false;
			}
		}
		return true;
	}

	// 定義一個方法,將皇后擺放的位置輸出
	public void print() {
		count++;
		for (int i = 0; i < array.length; i++) {
			System.out.print(array[i] + " ");
		}
		System.out.println();
	}
}

本章思維導圖

在這裏插入圖片描述

發表評論
所有評論
還沒有人評論,想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章