前言

先說一下遞歸算法的重要性，後面的快速排序、歸併排序都會用到遞歸。可見其重要性
這裏學的時候，自我感覺有點難，邏輯有點混亂，可以先學習一遍，然後到了後面用到的時候，再來學習一遍。

一、遞歸

2.1 遞歸簡單介紹

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

2.2 重要規則

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

2.3 遞歸形式

遞歸就是函數調用自己本身，但是要加上 必須的條件，以免變成 死龜

形式如下


public void func(int n){
	if(condition){
		
	}
	func(n-1);
}

2.4 遞歸能解決的問題

各種數學問題如: 8皇后問題 , 漢諾塔, 階乘問題, 迷宮問題, 球和籃子的問題(google編程大賽)
各種算法中也會使用到遞歸，比如 快排，歸併排序，二分查找，分治算法 等.
將用棧解決的問題–>第歸代碼比較簡潔

二、打印問題

2.1 介紹

通過打印來了解遞歸

2.2 代碼

/**
 * 打印問題.
 * 當 n 爲 4時 輸出的順序：n=2 n=3 n=4
 * @param n
 */
 public static void test01(int n) {
    if (n > 2) {
        test01(n - 1);   // 如果爲 + 時，會成爲 棧溢出，報錯：java.lang.StackOverflowError
    }
    System.out.println("n=" + n);
}

2.3 代碼測試

當傳入 4 時，打印的順序時是：

2.4 思路分析和圖解

可以看出每一次調用都要先走進入，走到最後，在一步步走出來，進行打印。

三、階乘問題

3.1 介紹

用遞歸實現階乘問題，如 4！= 432*1

3.2 代碼實現

/**
 * 階乘問題
 *
 * @param n
 * @return
 */
public static int factorial(int n) {
    if (n == 1) {
        return 1;
    } else {
        return n*factorial(n - 1); //n=3時， f(3) = 3*f(2)=3*2*f(1)= 3*2*1, 依次類推
    }
}

3.3 測試與分析

當傳入 4 時，factorial（4） = 4factorial(3)
factorial(3) = 3factorial(2)
factorial(2) = 2factorial(1)
factorial(1) = 1
所以最終就爲 factorial（4）= 4321=24.

四、遞歸-迷宮問題

4.1 問題介紹

上圖看介紹：初始化二維數組爲地圖，map[8][7]，1代表紅色的牆。小球初始位置map[1][1] ，找到最終位置map[6][5]。

4.2 代碼實現

package com.feng.ch08_recursion;

/*
 * 遞歸解決迷宮問題
 * 從 map[1][1] 找到 map[6][5]
 * 開始時，只有遞歸，沒有回溯，
 * 查看回溯請求：
 *   1、map[1][2] = 1;map[2][2] = 1; ，在運行就看到了回溯，都設置爲了 3
 * */
public class R2_MiGong {
    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;
        }
        // 左右置爲 2
        for (int i = 0; i < 8; i++) {
            map[i][0] = 1;
            map[i][6] = 1;
        }

        // 設置擋板 ，用 1 表示
        map[3][1] = 1;
        map[3][2] = 1;
//        map[1][2] = 1;
//        map[2][2] = 1;

        // 輸出  初始化的地圖
        for (int i = 0; i < map.length; i++) {
            for (int j = 0; j < map[i].length; j++) {
                System.out.printf("%d\t", map[i][j]);
            }
            System.out.println();
        }

        // 使用  遞歸回溯  給小球找路
        setWay(map, 1, 1);

        // 輸出 遞歸後的地圖
        System.out.println();
        for (int i = 0; i < map.length; i++) {
            for (int j = 0; j < map[i].length; j++) {
                System.out.printf("%d\t", map[i][j]);
            }
            System.out.println();
        }
    }

    // 使用  遞歸回溯  來給小球找路
    /*
     *
     * 說明：
     * 1、map表示地圖
     * 2、i, j 表示從地圖的哪個位置開始出發 ，（1 ， 1）；
     * 3、如果小球能到 map[6][5] 位置，則說明通路 找到。
     * 4、約定： 當 map[i][j] 爲0 表示該點沒有走過； 當爲 1 表示牆；2 表示通路可以走； 3 表示該點已經走過。但是走不通
     * 5、在走迷宮時，需要確定一個策略（方法） 下-》右-》上-》左 ，
     * 如果該點走不通，再 回溯
     *
     * @param map 表示地圖
     * @param i   從哪個位置開始找
     * @param j
     * @return 如果找到通路，就返回true， 否則返回false
     * */
    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)) { // 向下走
                    System.out.println("走過i=" + (i + 1) + ", j=" + j);
                    return true;
                } else if (setWay(map, i, j + 1)) {  // 向右走
                    System.out.println("走過i=" + i + ", j=" + (j + 1));
                    return true;
                } else if (setWay(map, i - 1, j)) {  // 向上走
                    System.out.println("走過i=" + (i - 1) + ", j=" + j);
                    return true;
                } else if (setWay(map, i, j - 1)) {  // 向左走
                    System.out.println("走過i=" + i + ", j=" + (j - 1));
                    return true;
                } else {
                    map[i][j] = 3;
                    return false;
                }
            } else { // 如果 map[i][j] !=0, 可能是 1， 2， 3
                return false;
            }
        }
    }
}

4.2 測試結果

五、八皇后問題

5.1 問題介紹

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

5.2 思路分析

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

5.3 代碼實現

package com.feng.ch08_recursion;

public class R3_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) {
        R3_Queue8 queue8 = new R3_Queue8();
        queue8.check(0);

        System.out.printf("一共有%d種解法\n", count);
        System.out.printf("一共判斷衝突的次數%d次", judgeCount); // 1.5w
    }

    /*
     * 編寫一個方法， 放置第 n 個皇后
     * 特別注意： check 是每一次 遞歸時，進入到 check中都有 for (int i = 0; i<max; i++) , 因此 會有回溯
     * */
    public void check(int n) {
        if(n == max) {  //n = 8 , 其實8個皇后就既然放好
            print();
            return;
        }

        // 依次放入皇后，並判斷是否衝突
        for(int i = 0; i < max; i++) {
            // 先把當前這個皇后 n ，放到改行的第 1 列
            array[n] = i;
            // 判斷當放置 第 n 個皇后到 i 列，是否衝突
            if (judge(n)) {
                // 接着放 n+1 個皇后，即開始遞歸
                check(n + 1);
            }
            /*
             * 如果衝突，就繼續執行 array[n] = i; 即將第 n 個皇后，放置在本行的 後移的一個位置
             * */
        }
    }

    // 查看當我們放置第 n 個皇后，就去檢測該皇后是否和前面已經擺放的皇后衝突
    /*
     * Math.abs() : 求絕對值的方法
     *
     * @param n 表示第 n 個皇后
     * @return
     * */
    private boolean judge(int n) {
        judgeCount++;
        for (int i = 0; i < n; i++) {
            /*
             * 說明：
             * 1、array[i] == array[n] ： 表示判斷 第 n 個皇后是否和前面的 n-1 個皇后在同一列
             * 2、Math.abs(n - i) == Math.abs(array[n] - array[i]) ：
             * */
            if (array[i] == array[n] || Math.abs(n - i) == Math.abs(array[n] - array[i])) { // 如果爲 true，則爲同一列
                return false;
            }
        }
        return true;
    }

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

數據結構與算法學習九：學習遞歸。遞歸的經典實例：打印問題、階乘問題、遞歸-迷宮問題、八皇后問題

文章目錄

前言