東哥手把手帶你刷二叉樹（第二期）

讀完本文，你不僅學會了算法套路，還可以順便去 LeetCode 上拿下如下題目：

654.最大二叉樹

105.從前序與中序遍歷序列構造二叉樹

106.從中序與后序遍歷序列構造二叉樹

-----------

上篇文章 手把手教你刷二叉樹（第一篇） 連刷了三道二叉樹題目，很多讀者直呼內行。其實二叉樹相關的算法真的不難，本文再來三道，手把手帶你看看樹的算法到底怎么做。

先來復習一下，我們說過寫樹的算法，關鍵思路如下：

把題目的要求細化，搞清楚根節點應該做什么，然后剩下的事情拋給前/中/后序的遍歷框架就行了，我們千萬不要跳進遞歸的細節里，你的腦袋才能壓幾個棧呀。

也許你還不太理解這句話，我們下面來看例子。

PS：我認真寫了 100 多篇原創，手把手刷 200 道力扣題目，全部發布在 labuladong的算法小抄，持續更新。建議收藏，按照我的文章順序刷題，掌握各種算法套路后投再入題海就如魚得水了。

構造最大二叉樹

先來道簡單的，這是力扣第 654 題，題目如下：

函數簽名如下：

TreeNode constructMaximumBinaryTree(int[] nums);

按照我們剛才說的，先明確根節點做什么？對於構造二叉樹的問題，根節點要做的就是把想辦法把自己構造出來。

我們肯定要遍歷數組把找到最大值 maxVal，把根節點 root 做出來，然后對 maxVal 左邊的數組和右邊的數組進行遞歸調用，作為 root 的左右子樹。

按照題目給出的例子，輸入的數組為 [3,2,1,6,0,5]，對於整棵樹的根節點來說，其實在做這件事：

TreeNode constructMaximumBinaryTree([3,2,1,6,0,5]) {
    // 找到數組中的最大值
    TreeNode root = new TreeNode(6);
    // 遞歸調用構造左右子樹
    root.left = constructMaximumBinaryTree([3,2,1]);
    root.right = constructMaximumBinaryTree([0,5]);
    return root;
}

再詳細一點，就是如下偽碼：

TreeNode constructMaximumBinaryTree(int[] nums) {
    if (nums is empty) return null;
    // 找到數組中的最大值
    int maxVal = Integer.MIN_VALUE;
    int index = 0;
    for (int i = 0; i < nums.length; i++) {
        if (nums[i] > maxVal) {
            maxVal = nums[i];
            index = i;
        }
    }

    TreeNode root = new TreeNode(maxVal);
    // 遞歸調用構造左右子樹
    root.left = constructMaximumBinaryTree(nums[0..index-1]);
    root.right = constructMaximumBinaryTree(nums[index+1..nums.length-1]);
    return root;
}

看懂了嗎？對於每個根節點，只需要找到當前 nums 中的最大值和對應的索引，然后遞歸調用左右數組構造左右子樹即可。

明確了思路，我們可以重新寫一個輔助函數 build，來控制 nums 的索引：

/* 主函數 */
TreeNode constructMaximumBinaryTree(int[] nums) {
    return build(nums, 0, nums.length - 1);
}

/* 將 nums[lo..hi] 構造成符合條件的樹，返回根節點 */
TreeNode build(int[] nums, int lo, int hi) {
    // base case
    if (lo > hi) {
        return null;
    }

    // 找到數組中的最大值和對應的索引
    int index = -1, maxVal = Integer.MIN_VALUE;
    for (int i = lo; i <= hi; i++) {
        if (maxVal < nums[i]) {
            index = i;
            maxVal = nums[i];
        }
    }

    TreeNode root = new TreeNode(maxVal);
    // 遞歸調用構造左右子樹
    root.left = build(nums, lo, index - 1);
    root.right = build(nums, index + 1, hi);
    
    return root;
}

至此，這道題就做完了，還是挺簡單的對吧，下面看兩道更困難一些的。

通過前序和中序遍歷結果構造二叉樹

經典問題了，面試/筆試中常考，力扣第 105 題就是這個問題：

函數簽名如下：

TreeNode buildTree(int[] preorder, int[] inorder);

廢話不多說，直接來想思路，首先思考，根節點應該做什么。

類似上一題，我們肯定要想辦法確定根節點的值，把根節點做出來，然后遞歸構造左右子樹即可。

我們先來回顧一下，前序遍歷和中序遍歷的結果有什么特點？

void traverse(TreeNode root) {
    // 前序遍歷
    preorder.add(root.val);
    traverse(root.left);
    traverse(root.right);
}

void traverse(TreeNode root) {
    traverse(root.left);
    // 中序遍歷
    inorder.add(root.val);
    traverse(root.right);
}

前文 二叉樹就那幾個框架 寫過，這樣的遍歷順序差異，導致了 preorder 和 inorder 數組中的元素分布有如下特點：

找到根節點是很簡單的，前序遍歷的第一個值 preorder[0] 就是根節點的值，關鍵在於如何通過根節點的值，將 preorder 和 postorder 數組划分成兩半，構造根節點的左右子樹？

PS：我認真寫了 100 多篇原創，手把手刷 200 道力扣題目，全部發布在 labuladong的算法小抄，持續更新。建議收藏，按照我的文章順序刷題，掌握各種算法套路后投再入題海就如魚得水了。

換句話說，對於以下代碼中的 ? 部分應該填入什么：

/* 主函數 */
TreeNode buildTree(int[] preorder, int[] inorder) {
    return build(preorder, 0, preorder.length - 1,
                 inorder, 0, inorder.length - 1);
}

/* 
   若前序遍歷數組為 preorder[preStart..preEnd]，
   后續遍歷數組為 postorder[postStart..postEnd]，
   構造二叉樹，返回該二叉樹的根節點 
*/
TreeNode build(int[] preorder, int preStart, int preEnd, 
               int[] inorder, int inStart, int inEnd) {
    // root 節點對應的值就是前序遍歷數組的第一個元素
    int rootVal = preorder[preStart];
    // rootVal 在中序遍歷數組中的索引
    int index = 0;
    for (int i = inStart; i <= inEnd; i++) {
        if (inorder[i] == rootVal) {
            index = i;
            break;
        }
    }

    TreeNode root = new TreeNode(rootVal);
    // 遞歸構造左右子樹
    root.left = build(preorder, ?, ?,
                      inorder, ?, ?);

    root.right = build(preorder, ?, ?,
                       inorder, ?, ?);
    return root;
}

對於代碼中的 rootVal 和 index 變量，就是下圖這種情況：

現在我們來看圖做填空題，下面這幾個問號處應該填什么：

root.left = build(preorder, ?, ?,
                  inorder, ?, ?);

root.right = build(preorder, ?, ?,
                   inorder, ?, ?);

對於左右子樹對應的 inorder 數組的起始索引和終止索引比較容易確定：

root.left = build(preorder, ?, ?,
                  inorder, inStart, index - 1);

root.right = build(preorder, ?, ?,
                   inorder, index + 1, inEnd);

對於 preorder 數組呢？如何確定左右數組對應的起始索引和終止索引？

這個可以通過左子樹的節點數推導出來，假設左子樹的節點數為 leftSize，那么 preorder 數組上的索引情況是這樣的：

看着這個圖就可以把 preorder 對應的索引寫進去了：

int leftSize = index - inStart;

root.left = build(preorder, preStart + 1, preStart + leftSize,
                  inorder, inStart, index - 1);

root.right = build(preorder, preStart + leftSize + 1, preEnd,
                   inorder, index + 1, inEnd);

至此，整個算法思路就完成了，我們再補一補 base case 即可寫出解法代碼：

TreeNode build(int[] preorder, int preStart, int preEnd, 
               int[] inorder, int inStart, int inEnd) {
        
    if (preStart > preEnd) {
        return null;
    }

    // root 節點對應的值就是前序遍歷數組的第一個元素
    int rootVal = preorder[preStart];
    // rootVal 在中序遍歷數組中的索引
    int index = 0;
    for (int i = inStart; i <= inEnd; i++) {
        if (inorder[i] == rootVal) {
            index = i;
            break;
        }
    }

    int leftSize = index - inStart;

    // 先構造出當前根節點
    TreeNode root = new TreeNode(rootVal);
    // 遞歸構造左右子樹
    root.left = build(preorder, preStart + 1, preStart + leftSize,
                      inorder, inStart, index - 1);

    root.right = build(preorder, preStart + leftSize + 1, preEnd,
                       inorder, index + 1, inEnd);
    return root;
}

我們的主函數只要調用 build 函數即可，你看着函數這么多參數，解法這么多代碼，似乎比我們上面講的那道題難很多，讓人望而生畏，實際上呢，這些參數無非就是控制數組起止位置的，畫個圖就能解決了。

通過后序和中序遍歷結果構造二叉樹

類似上一題，這次我們利用后序和中序遍歷的結果數組來還原二叉樹，這是力扣第 106 題：

函數簽名如下：

TreeNode buildTree(int[] inorder, int[] postorder);

類似的，看下后序和中序遍歷的特點：

void traverse(TreeNode root) {
    traverse(root.left);
    traverse(root.right);
    // 前序遍歷
    postorder.add(root.val);
}

void traverse(TreeNode root) {
    traverse(root.left);
    // 中序遍歷
    inorder.add(root.val);
    traverse(root.right);
}

這樣的遍歷順序差異，導致了 preorder 和 inorder 數組中的元素分布有如下特點：

這道題和上一題的關鍵區別是，后序遍歷和前序遍歷相反，根節點對應的值為 postorder 的最后一個元素。

整體的算法框架和上一題非常類似，我們依然寫一個輔助函數 build：

TreeNode buildTree(int[] inorder, int[] postorder) {
    return build(inorder, 0, inorder.length - 1,
                 postorder, 0, postorder.length - 1);
}

TreeNode build(int[] inorder, int inStart, int inEnd,
               int[] postorder, int postStart, int postEnd) {
    // root 節點對應的值就是后序遍歷數組的最后一個元素
    int rootVal = postorder[postEnd];
    // rootVal 在中序遍歷數組中的索引
    int index = 0;
    for (int i = inStart; i <= inEnd; i++) {
        if (inorder[i] == rootVal) {
            index = i;
            break;
        }
    }

    TreeNode root = new TreeNode(rootVal);
    // 遞歸構造左右子樹
    root.left = build(preorder, ?, ?,
                      inorder, ?, ?);

    root.right = build(preorder, ?, ?,
                       inorder, ?, ?);
    return root;
}

現在 postoder 和 inorder 對應的狀態如下：

我們可以按照上圖將問號處的索引正確填入：

int leftSize = index - inStart;

root.left = build(inorder, inStart, index - 1,
                  postorder, postStart, postStart + leftSize - 1);

root.right = build(inorder, index + 1, inEnd,
                   postorder, postStart + leftSize, postEnd - 1);

綜上，可以寫出完整的解法代碼：

TreeNode build(int[] inorder, int inStart, int inEnd,
               int[] postorder, int postStart, int postEnd) {

    if (inStart > inEnd) {
        return null;
    }
    // root 節點對應的值就是后序遍歷數組的最后一個元素
    int rootVal = postorder[postEnd];
    // rootVal 在中序遍歷數組中的索引
    int index = 0;
    for (int i = inStart; i <= inEnd; i++) {
        if (inorder[i] == rootVal) {
            index = i;
            break;
        }
    }
    // 左子樹的節點個數
    int leftSize = index - inStart;
    TreeNode root = new TreeNode(rootVal);
    // 遞歸構造左右子樹
    root.left = build(inorder, inStart, index - 1,
                        postorder, postStart, postStart + leftSize - 1);
    
    root.right = build(inorder, index + 1, inEnd,
                        postorder, postStart + leftSize, postEnd - 1);
    return root;
}

有了前一題的鋪墊，這道題很快就解決了，無非就是 rootVal 變成了最后一個元素，再改改遞歸函數的參數而已，只要明白二叉樹的特性，也不難寫出來。

最后呼應下前文，做二叉樹的問題，關鍵是把題目的要求細化，搞清楚根節點應該做什么，然后剩下的事情拋給前/中/后序的遍歷框架就行了。

現在你是否明白其中的玄妙了呢？

＿＿＿＿＿＿＿＿＿＿＿＿＿

我的 在線電子書 有 100 篇原創文章，手把手帶刷 200 道力扣題目，建議收藏！對應的 GitHub 算法倉庫 已經獲得了 70k star，歡迎標星！