算法-如何理解遞歸，寫好遞歸函數

不是每一個程序員天生對遞歸理解深入，剛入大一時候，當別人寫出第一個求最大公約數的遞歸函數時，對其多麼的驚歎，居然能夠不用循環，居然代碼能夠這麼簡潔，確實遞歸在大多數狀況下實現時候代碼很短，大部分人也知道遞歸，也能基本看懂遞歸，但是卻常常不知道怎麼寫，或者寫出來的遞歸常常死循環，寫算法每每也是學的是套路，只有極少數人是創造算法的，大部分人是用算法的，而遞歸是確實有套路可循的。

本文即從遞歸的扎馬步開始，從幾個簡單例子到通用套路，一步一步拆解遞歸

1 遞歸的三要素

寫遞歸，就是寫三要素的實現，三要素分別爲函數，邊界，遞推公式，剛開始只要記住要這麼寫，寫幾個算法以後，就能慢慢明白爲何要這樣搞。

1.1 遞歸首要元素-函數

明確你的函數是幹什麼用的，函數的入參應該是什麼，返回值是什麼，這三個問題，先從函數是幹什麼用的開始，你能夠定義一個函數f() 假設已經實現了每一步遞歸的實現，再去明確這個實現 到底作了什麼，入參至少要什麼，返回值和參數返回能夠理解爲是一個東西，都是爲了返回給上層調用或者全局的一個數據，想清楚函數的三個要素，那你的函數就定義好了。

1.2 遞歸邊界、跳出遞歸

一樣，先這樣去作，再去想爲何，這一步要判斷的就是函數的入參，入參的null ，入參爲初始值，好比斐波那契數列的前1位或者2位，開始時候可能不必定想的徹底，那不要緊，下面的一步還會繼續完善，因此我這裏舉得例子是斐波那契的前1或2位，而不是直接說結論，這一步驟是在函數的實現裏面，因此考慮方式就是假設，入參到了臨界值或者初始值，或者特殊值，你要判斷一下，第一遍寫的時候好比斐波那契，能夠直接這麼寫

if (n == 1)
  return 1;
if (n == 2)
  return 1;

想到的不必定徹底對，或者那麼地很優雅， 不要緊，只要想到要考慮邊界就能夠了。下面就是想邊界的意義是什麼？有兩點，其一，異常值邊界，其二遞歸結束判斷，好比此題中的n < 0 怎麼辦，和 n == 1 和 n == 2 就分別對應前面說的，固然這兩點可能考慮不那麼徹底，假設你只考慮了像前面代碼中的，或者寫邊界時候發現寫的多了，或者冗餘了，這樣不影響程序的結果，那麼寫完遞推公式，咱們再來回顧邊界問題。

1.3 遞推公式

這個就要先談意義，再談實現了，意義在於逐漸減小算法的規模，或者定義一種方式讓輸入的值儘量地靠近臨界值，也就是找一個關係f(n) 與 f(n-x)序列的關係，f(n) 表明要解決的問題規模，f(n-x) 比n小的問題規模的函數值，這是遞歸函數中的關鍵一步，沒有遞推公式，就沒有遞歸。例如斐波那契序列，中的遞推公式是f(n)=f(n-1) + f(n-2)咱們來觀察這個公式，發現其第n 於 n-1 和 n-2 有關係，因此咱們來看，若是輸入任何整數，那麼n-1,n-2 可能取值是負數，0，1+，能夠看到邊界0和負數沒有考慮在內，因此，這時回顧前面1.2 的遞歸，咱們來補充一下邊界後獲得：

if (n <= 2)
  return 1;

2 遞歸的案例

下面經過三個簡單例子，咱們來練習使用遞歸，分別是青蛙跳臺階問題，等同於斐波那契序列，遞歸方式反轉單鏈表，遞歸遍歷樹，以及針對三個

2.1 青蛙跳臺階問題

第必定義函數,明確函數只有一個惟一的輸入值n ，第二找到遞歸結束條件或者遞歸邊界，能夠發現當臺階是1或者2時候最容易獲得，至於遞推式，能夠發現青蛙在每次跳的時候有兩種跳法，那青蛙怎麼到達第n 個臺階，就是有兩種跳法，分別對應f(n-1) 和 f(n-2) ，因此遞歸式就是f(n)=f(n-1)+f(n-2) ,那麼整個算法就是以下：

//一隻青蛙一次能夠跳上1級臺階，也能夠跳上2級。求該青蛙跳上一個n級的臺階總共有多少種跳法。
//1。定義函數
public int f2(int n) {
   //2.肯定邊界
    if (n == 1)
        return 1;
    if (n == 2)
        return 2;
   //3.肯定遞歸式
    return f2(n-1) + f2(n-2);
}

繼續檢查邊界，發現n若是小於1，就會陷入死循環，那麼程序能夠改爲這樣：

if (n == 1)
  return 1;

if (n == 2)
  return 2;

if (n < 1)
  return 0;
  
//固然簡單寫，能夠這樣搞

if (n < 1)
  return 0;
if (n <= 2)
  return n;

2.2 遞歸方式反轉單鏈表

單鏈表的反轉，通常考慮到是雙指針反轉，固然遞歸寫也能夠，一樣，首先定義函數，發現函數只有一個入參即節點node 這個node 在根節點或者任意中間節點都適用，其二肯定邊界，在反轉單鏈表時候，可能會漏了node.next 的邊界，此時兩種方式，1，冗餘寫，只要你考慮到了，這多是邊界，你多寫了絕對不會錯，甚至，你能夠多寫兩到三步也徹底沒問題，2，少寫的話，就寫完遞歸方式再來檢查，好比反轉單鏈表這個題，你會看到若是node.next 爲空，那麼node.next.next 就會報空指針問題，通常寫完遞歸式後最好回頭檢查一下邊界，能夠查缺補漏，去冗餘或者補條件。

此題的核心點是解開鏈的遞歸式，就是

Node last = f3(node.next); //假設當前節點的下一節點後的鏈表已經反轉
node.next.next = node; //當前節點指向的節點指向當前節點
node.next = null ;//原來當前節點是指向下一節點的，解開當前節點，並把節點指向空
//此處解釋，爲何指向空，首先能夠將node節點理解爲第一個節點，那麼第一節點反轉後，就是最後一個節點，則指向是null，不然它仍是指向2，就有問題喲
//那麼若是不是第一個節點呢？這個指針是怎麼指向的

舉個例子，假設，單鏈表是1，2，3，4，5那麼遞歸的過程以下圖:

看圖，能夠發現每一步的當前節點，放入反轉鏈表後，都是最後一個，那它必然指向null 這樣懂了把！

class Node{
    int data;
    Node next;
} 
public Node f3(Node node) {
    //2.肯定返回邊界
    if (node == null || node.next == null)
        return node;
    //3.拿到遞歸推導
    Node last = f3(node.next);
    node.next.next = node;
    node.next = null ;//這個的做用是什麼?,解開死循環，最後是有A->B,B->A
    return last;
}

2.3 遞歸遍歷樹

遞歸遍歷樹也是最簡單的，假設你以前沒有看過遍歷的代碼，那麼從零來開始考慮這個問題，首先定義函數，確認入參和單鏈表反轉相似，只須要一個TreeNode 節點，而後考慮邊界爲null ，和不爲null ，你首先想到是否是這樣？

if (node == null)
  return ;

if (node.left == null && node.right == null) {
  System.out.pritln(node.val);
  return ;
}

如今看起來是有點冗餘，可是假設你並不知道，那麼接下來下遞歸式，以先序爲例

//首先節點自己
System.out.println(node.val);      
//而後節點左
preOrder(node.left);      
//而後節點右 
preOrder(node.right);

就這樣完了，而後回顧前面的邊界問題，只有上面的代碼兩行，能夠看到在節點爲null 的時候，就直接return 了，不用考慮子節點，字節點的邊界在父節點的邊界中已經考慮到了，固然寫了這條邊界徹底不影響程序運行哦，因此最終的前中後序遍歷以下代碼：

//二叉樹前序遍歷
public static void preOrder(TreeNode node) {
    if (node == null)
        return;
    System.out.println(node.val);
    preOrder(node.left);
    preOrder(node.right);
}

//二叉樹中序遍歷
public static void inOrder(TreeNode node) {
    if (node == null)
        return;
    preOrder(node.left);
    System.out.println(node.val);
    preOrder(node.right);
}

//二叉樹後序遍歷
public static void postOrder(TreeNode node) {
    if (node == null)
        return;
    preOrder(node.left);
    preOrder(node.right);
    System.out.println(node.val);
}

2.4 經過一個序列構造二叉樹

下面，咱們補一個遞歸算法題，輸入一個二叉樹序列，來還原構造二叉樹，順便測試一下前面的遍歷樹的代碼，一樣熟悉了遞歸的套路後，咱們直接來寫代碼

//1.定義函數確認，只須要一個參數，即剩餘序列
public static TreeNode createBinaryTree(LinkedList<Integer> inputList) {
        //定義一個空的樹節點，此處爲了整齊劃一，在邊界和遞歸體裏面均可以用，因此寫在第一行
        TreeNode node = null;
        //2.邊界
        if (inputList == null || inputList.isEmpty())
            return node;

        //3.主要遞歸體，從鏈表中刪除並取第一個元素，構建好左右節點，最後返回當前節點
        Integer data = inputList.removeFirst();
        //data，主要是異常值判斷，前面已經判斷過鏈表爲空了
        if (data != null) {
            node = new TreeNode(data);
            node.left = createBinaryTree(inputList);
            node.right = createBinaryTree(inputList);
        }
        return node;
}

    public static void main(String[] args) {
        //前序遍歷序列
        LinkedList<Integer> inputList = new LinkedList<Integer>(Arrays.asList(new Integer[]{3,2,9,null,null,10,null,null,8,null,4}));

        TreeNode node = createBinaryTree(inputList);

        //前序遍歷
        System.out.println("前序遍歷：");
        preOrder(node);

    }

3. 總結

如何寫好遞歸，就三步，首先確認函數的輸入值，返回值，即函數自己要作什麼功能。其次，判斷邊界，將能夠想到的邊界都寫一下。最後寫遞歸體，包括函數返回值，而後回去檢查邊界，對邊界增刪改查。

ps: 更多的狀況下，只是沒想好算法是怎麼樣，若是想好了，可以用模擬法，把整個圖畫出來，寫代碼就參考本文，便可一鼓作氣。。。
吳邪，小三爺，混跡於後臺，大數據，人工智能領域的小菜鳥。
更多請關注