萬字長文！二叉樹入門和刷題看這篇就夠了！

今天是小浩算法 “365刷題計劃” 二叉樹入門 - 整合篇。本篇作爲入門整合篇，已經砍去難度較大的知識點，所有列出的內容，均爲必須掌握。因爲很長，寫下目錄：

二叉樹是啥
二叉樹的最大深度（DFS）
二叉樹的層次遍歷（BFS）
二叉搜索樹驗證
二叉搜索樹查找
二叉搜索樹刪除
平衡二叉樹
完全二叉樹
二叉樹的剪枝

01 PART

二叉樹是啥

二叉樹有多重要？單就面試而言，在 leetcode 中二叉樹相關的題目佔據了300多道，近三分之一。同時，二叉樹在整個算法板塊中還起到承上啓下的作用：不但是數組和鏈表的延伸，又可以作爲圖的基礎。總之，非常重要！

什麼是二叉樹？官方是這樣定義的：在計算機科學中，二叉樹是每個結點最多有兩個子樹的樹結構。通常子樹被稱作“左子樹”（left subtree）和“右子樹”（right subtree）。

上面那是個玩笑，二叉樹長這樣：

二叉樹常被用於實現二叉查找樹和二叉堆。樹比鏈表稍微複雜，因爲鏈表是線性數據結構，而樹不是。樹的問題很多都可以由廣度優先搜索或深度優先搜索解決。

一般而言，我們會看到下面這些與樹相關的術語：

小浩概念

與樹相關的術語

樹的結點（node）：包含一個數據元素及若干指向子樹的分支；

孩子結點（child node）：結點的子樹的根稱爲該結點的孩子；

雙親結點：B 結點是A 結點的孩子，則A結點是B 結點的雙親；

兄弟結點：同一雙親的孩子結點；堂兄結點：同一層上結點；

祖先結點: 從根到該結點的所經分支上的所有結點

子孫結點：以某結點爲根的子樹中任一結點都稱爲該結點的子孫

結點層：根結點的層定義爲1；根的孩子爲第二層結點，依此類推；

樹的深度：樹中最大的結點層

結點的度：結點子樹的個數

樹的度：樹中最大的結點度。

葉子結點：也叫終端結點，是度爲 0 的結點；

分枝結點：度不爲0的結點；

有序樹：子樹有序的樹，比如家族樹；

無序樹：不考慮子樹的順序；

瞭解了上面的基本概念之後。我們將通過幾道例題，爲大家引入樹的經典操作。

02 PART

二叉樹最大深度

複習上面的概念：樹的深度指的是樹中最大的結點層。

第104題：給定一個二叉樹，找出其最大深度。二叉樹的深度爲根節點到最遠葉子節點的最長路徑上的節點數。

說明: 葉子節點是指沒有子節點的節點。

示例：

給定二叉樹 [3,9,20,null,null,15,7]，

基本概念掌握：每個節點的深度與它左右子樹的深度有關，且等於其左右子樹最大深度值加上 1。即：

maxDepth(root) =
max(maxDepth(root.left),maxDepth(root.right)) + 1

以 [3,9,20,null,null,15,7] 爲例：

我們要對根節點的最大深度求解，就要對其左右子樹的深度進行求解

我們看出。以4爲根節點的子樹沒有左右節點，其深度爲1。而以20爲根節點的子樹的深度，同樣取決於它的左右子樹深度。

對於15和7的子樹，我們可以一眼看出其深度爲1。

由此我們可以得到根節點的最大深度爲

maxDepth(root-3)
=max(maxDepth(sub-4),maxDepth(sub-20))+1
=max(1,max(maxDepth(sub-15),maxDepth(sub-7))+1)+1
=max(1,max(1,1)+1)+1
=max(1,2)+1
=3

根據分析，我們通過遞歸進行求解：

1//Go
 2func maxDepth(root *TreeNode) int {
 3    if root == nil {
 4        return 0
 5    }
 6    return max(maxDepth(root.Left), maxDepth(root.Right)) + 1
 7}
 8
 9func max(a int, b int) int {
10    if a > b {
11        return a
12    }
13    return b
14}

其實我們上面用的遞歸方式，本質上是使用了DFS的思想。所以這裏就可以引出什麼是DFS：深度優先搜索算法（Depth First Search），對於二叉樹而言，它沿着樹的深度遍歷樹的節點，儘可能深的搜索樹的分支，這一過程一直進行到已發現從源節點可達的所有節點爲止。( 注意，這裏的前提是對二叉樹而言。DFS本身作爲圖算法的一種，在後續我會單獨拉出來和回溯放一起講。)

如上圖二叉樹，它的訪問順序爲：

A-B-D-E-C-F-G

到這裏，我們思考一個問題？雖然我們用遞歸的方式根據DFS的思想順利完成了題目。但是這種方式的缺點卻顯而易見。因爲在遞歸中，如果層級過深，我們很可能保存過多的臨時變量，導致棧溢出。這也是爲什麼我們一般不在後臺代碼中使用遞歸的原因。如果不理解，下面我們詳細說明：

事實上，函數調用的參數是通過棧空間來傳遞的，在調用過程中會佔用線程的棧資源。而遞歸調用，只有走到最後的結束點後函數才能依次退出，而未到達最後的結束點之前，佔用的棧空間一直沒有釋放，如果遞歸調用次數過多，就可能導致佔用的棧資源超過線程的最大值，從而導致棧溢出，導致程序的異常退出。

所以，我們引出下面的話題：如何將遞歸的代碼轉化成非遞歸的形式。這裏請記住，基本所有的遞歸轉非遞歸，都可以通過棧來進行實現。非遞歸的DFS，代碼如下：


 1//java
 2private List<TreeNode> traversal(TreeNode root) {
 3    List<TreeNode> res = new ArrayList<>();
 4    Stack<TreeNode> stack = new Stack<>();
 5    stack.add(root);
 6    while (!stack.empty()) {
 7        TreeNode node = stack.peek();
 8        res.add(node);
 9        stack.pop();
10        if (node.right != null) {
11            stack.push(node.right);
12        }
13        if (node.left != null) {
14            stack.push(node.left);
15        }
16    }
17    return res;
18}

上面的代碼，唯一需要強調的是，爲什麼需要先右後左壓入數據？是因爲我們需要將先訪問的數據，後壓入棧（請思考棧的特點）。

如果不理解代碼，請看下圖：

說明：

1：首先將a壓入棧
2：a彈棧，將c、b壓入棧（注意順序）
3：b彈棧，將e、d壓入棧
4,5：d、e、c彈棧，將g、f壓入棧
6：f、g彈棧

至此，非遞歸的 DFS 就講解完畢了。那如何通過非遞歸DFS的方式，來對本題求解呢？相信已經很簡單了，這個下去自己試試就ok了了。

03 PART

二叉樹的層次遍歷

在上文中，我們通過例題學習了二叉樹的DFS（深度優先搜索），其實就是沿着一個方向一直向下遍歷。那我們可不可以按照高度一層一層的訪問樹中的數據呢？當然可以，就是本節中我們要講的BFS（寬度優先搜索），同時也被稱爲廣度優先搜索。

第102題：給定一個二叉樹，返回其按層次遍歷的節點值。（即逐層地，從左到右訪問所有節點）。

例如:

給定二叉樹: [3,9,20,null,null,15,7],

/ \

9 20

/  \

15 7

返回其層次遍歷結果：[[3],[9,20],[15,7]]

BFS，廣度/寬度優先。說白了就是從上到下，先把每一層遍歷完之後再遍歷一下一層。假如我們的樹如下：

按照BFS，訪問順序如下：

a->b->c->d->e->f->g

瞭解了BFS，我們開始對本題進行分析。同樣，我們先考慮本題的遞歸解法。想到遞歸，我們一般先想到DFS。我們可以對該二叉樹進行先序遍歷（根左右的順序），同時，記錄節點所在的層次level，並且對每一層都定義一個數組，然後將訪問到的節點值放入對應層的數組中。

假設給定二叉樹爲[3,9,20,null,null,15,7]，圖解如下：

根據分析，代碼如下：

1//Go
 2func levelOrder(root *TreeNode) [][]int {
 3    return dfs(root, 0, [][]int{})
 4}
 5
 6func dfs(root *TreeNode, level int, res [][]int) [][]int {
 7    if root == nil {
 8        return res
 9    }
10    if len(res) == level {
11        res = append(res, []int{root.Val})
12    } else {
13        res[level] = append(res[level], root.Val)
14    }
15    res = dfs(root.Left, level+1, res)
16    res = dfs(root.Right, level+1, res)
17    return res
18}

上面的解法，其實相當於是用DFS的方法實現了二叉樹的BFS。那我們能不能直接使用BFS的方式進行解題呢？當然可以。我們使用Queue的數據結構。我們將root節點初始化進隊列，通過消耗尾部，插入頭部的方式來完成BFS。

具體步驟如下圖：

根據分析，完成代碼：

1//Go
 2func levelOrder(root *TreeNode) [][]int {
 3    var result [][]int
 4    if root == nil {
 5        return result
 6    }
 7    // 定義一個雙向隊列
 8    queue := list.New()
 9    // 頭部插入根節點
10    queue.PushFront(root)
11    // 進行廣度搜索
12    for queue.Len() > 0 {
13        var currentLevel []int
14        listLength := queue.Len()
15        for i := 0; i < listLength; i++ {
16            // queue.Back()：返回隊列中最後一個元素
17            // queue.Remove(queue.Back()).(*TreeNode) ： 移除隊列中最後一個元素並將其轉化爲TreeNode類型
18            node := queue.Remove(queue.Back()).(*TreeNode)
19            currentLevel = append(currentLevel, node.Val)
20            if node.Left != nil {
21                queue.PushFront(node.Left)
22            }
23            if node.Right != nil {
24                queue.PushFront(node.Right)
25            }
26        }
27        result = append(result, currentLevel)
28    }
29    return result
30}

04 PART

二叉搜索樹

BST是二叉搜索樹，很重要。BST是二叉搜索樹，很重要。BST是二叉搜索樹，很重要。重要的事情說三遍。

第98題：給定一個二叉樹，判斷其是否是一個有效的二叉搜索樹。

示例 1:

輸入:

/ \

1 4

 / \

3   6

輸出: false

解釋: 輸入爲: [5,1,4,null,null,3,6]。

根節點的值爲 5 ，但是其右子節點值爲 4 。

要驗證二叉搜索樹，首先得知道啥是二叉搜索樹。二叉搜索樹（Binary Search Tree），（又：二叉查找樹，二叉排序樹）它或者是一棵空樹，或者是具有下列性質的二叉樹：若它的左子樹不空，則左子樹上所有結點的值均小於它的根結點的值；若它的右子樹不空，則右子樹上所有結點的值均大於它的根結點的值；它的左、右子樹也分別爲二叉搜索樹。

這裏強調一下子樹的概念：設T是有根樹，a是T中的一個頂點，由a以及a的所有後裔（後代）導出的子圖稱爲有向樹T的子樹。具體來說，子樹就是樹的其中一個節點以及其下面的所有的節點所構成的樹。比如下面這就是一顆二叉搜索樹：

下面這兩個都不是：

圖中4節點位置的數值應該大於根節點
圖中3節點位置的數值應該大於根節點

回到題目，那我們如何來驗證一顆二叉搜索樹？首先看完題目，我們很容易想到遍歷整棵樹，比較所有節點，通過左節點值<節點值，右節點值＞節點值的方式來進行求解。但是這種解法是錯誤的，因爲對於任意一個節點，我們不光需要左節點值小於該節點，並且左子樹上的所有節點值都需要小於該節點。（右節點一致）所以我們在此引入上界與下界，用以保存之前的節點中出現的最大值與最小值。

代碼其實很簡單：

1//GO
 2func isValidBST(root *TreeNode) bool {
 3    if root == nil{
 4        return true
 5    }
 6    return isBST(root,math.MinInt64,math.MaxInt64)
 7}
 8
 9func isBST(root *TreeNode,min, max int) bool{
10    if root == nil{
11        return true
12    }
13    if min >= root.Val || max <= root.Val{
14        return false
15    }
16    return isBST(root.Left,min,root.Val) && isBST(root.Right,root.Val,max)
17}

難就難在，可能大家看不懂這個遞歸！沒事，祭出大殺器：

這裏需要強調的是，在每次遞歸中，我們除了進行左右節點的校驗，還需要與上下界進行判斷。其餘的就很簡單了。

05 PART

BST的查找

在上文中，我們學習了二叉搜索樹。那我們如何在二叉搜索樹中查找一個元素呢？

第700題：給定二叉搜索樹（BST）的根節點和一個值。你需要在BST中找到節點值等於給定值的節點。返回以該節點爲根的子樹。如果節點不存在，則返回 NULL。

例如，給定二叉搜索樹:

搜索: 2

你應該返回如下子樹:

在上述示例中，如果要找的值是 5，但因爲沒有節點值爲 5，我們應該返回 NULL。

先複習一下，二叉搜索樹（BST）的特性：

1.若它的左子樹不爲空，則所有左子樹上的值均小於其根節點的值

2.若它的右子樹不爲空，則所有右子樹上的值均大於其根節點得值

3.它的左右子樹也分別爲二叉搜索樹

如下圖就是一棵典型的BST：

現在我們來看題，假設目標值爲 val。根據BST的特性，我們可以很容易想到查找過程（上面的驗證比查找稍難一點）：

如果val小於當前結點的值，轉向其左子樹繼續搜索；
如果val大於當前結點的值，轉向其右子樹繼續搜索；
如果已找到，則返回當前結點。

很簡單，不是嗎？然後我們可以給出迭代和遞歸兩種解法（給個Java的吧！）：

 1//java
 2
 3//遞歸
 4public TreeNode searchBST(TreeNode root, int val) {
 5    if (root == null)
 6        return null;
 7    if (root.val > val) {
 8        return searchBST(root.left, val);
 9    } else if (root.val < val) {
10        return searchBST(root.right, val);
11    } else {
12        return root;
13    }
14}
15
16//迭代
17public TreeNode searchBST(TreeNode root, int val) {
18    while (root != null) {
19        if (root.val == val) {
20            return root;
21        } else if (root.val > val) {
22            root = root.left;
23        } else {
24            root = root.right;
25        }
26    }
27    return null;
28}

06 PART

BST的刪除

查找有了，下面自然就要講刪除。（爲啥說我要着重墨在BST上面，因爲BST這兩年在面試時非常高頻。面試官不可能說問你一個普通二叉樹的題目，要麼就是問堆，要麼就是問BST，或者就直接DFS考察回溯。）

第450題：給定一個二叉搜索樹的根節點 root 和一個值 key，刪除二叉搜索樹中的 key 對應的節點，並保證二叉搜索樹的性質不變。返回二叉搜索樹（有可能被更新）的根節點的引用。

一般來說，刪除節點可分爲兩個步驟：

首先找到需要刪除的節點；

如果找到了，刪除它。

說明：要求算法時間複雜度爲 O(h)，h 爲樹的高度。

示例:

root = [5,3,6,2,4,null,7]

key = 3

/ \

3 6

/ \ \

2 4 7

給定需要刪除的節點值是 3，所以我們首先找到 3 這個節點，然後刪除它。

一個正確的答案是 [5,4,6,2,null,null,7], 如下圖所示。

/ \

4 6

/ \

2 7

另一個正確答案是 [5,2,6,null,4,null,7]。

/ \

2 6

\ \

4   7

如果你看到了這裏，相信肯定知道BST是個啥了。所以直接分析題目。我們要刪除BST的一個節點，首先需要找到該節點。而找到之後，會出現三種情況。

待刪除的節點左子樹爲空，讓待刪除節點的右子樹替代自己。
待刪除的節點右子樹爲空，讓待刪除節點的左子樹替代自己。
如果待刪除的節點的左右子樹都不爲空。我們需要找到比當前節點小的最大節點（前驅），來替換自己

或者比當前節點大的最小節點（後繼），來替換自己。

分析完畢，直接上代碼。這裏我們給出通過後繼節點來替代自己的方案（可以自行實現另一種方案）：

1//go
 2func deleteNode(root *TreeNode, key int) *TreeNode {
 3    if root == nil {
 4        return nil
 5    }
 6    if key < root.Val {
 7        root.Left = deleteNode( root.Left, key )
 8        return root
 9    }
10    if key > root.Val {
11        root.Right = deleteNode( root.Right, key )
12        return root
13    }
14    //到這裏意味已經查找到目標
15    if root.Right == nil {
16        //右子樹爲空
17        return root.Left
18    }
19    if root.Left == nil {
20        //左子樹爲空
21        return root.Right
22    }
23    minNode := root.Right
24    for minNode.Left != nil {
25        //查找後繼
26        minNode = minNode.Left
27    }
28    root.Val = minNode.Val
29    root.Right = deleteMinNode( root.Right )
30    return root
31}
32
33
34func deleteMinNode( root *TreeNode ) *TreeNode {
35    if root.Left == nil {
36        pRight := root.Right
37        root.Right = nil
38        return pRight
39    }
40    root.Left = deleteMinNode( root.Left )
41    return root
42}

07 PART

平衡二叉樹

BST講解完了。上面也說了，別人考察我們肯定是考察特殊的。那二叉樹裏還有啥特殊的東東嘞？平衡二叉樹算是一個。

**第110題：給定一個二叉樹，判斷它是否是高度平衡的二叉樹。

本題中，一棵高度平衡二叉樹定義爲：**

一個二叉樹每個節點的左右兩個子樹的高度差的絕對值不超過1。

示例 1:

給定二叉樹 [3,9,20,null,null,15,7]

/ \

9 20

/  \

15 7

返回 true 。

示例 2:

給定二叉樹 [1,2,2,3,3,null,null,4,4]

3 3

/ \

4 4

返回 false 。

題其實是一道很簡單的題，主要是拿來複習一下高度。我們想判斷一棵樹是否滿足平衡二叉樹，無非就是判斷當前結點的兩個孩子是否滿足平衡，同時兩個孩子的高度差是否超過1。那隻要我們可以得到高度，再基於高度進行判斷即可。

這裏唯一要注意的是，當我們判定其中任意一個節點如果不滿足平衡二叉樹時，那說明整棵樹已經不是一顆平衡二叉樹，我們可以對其進行阻斷，不需要繼續遞歸下去。

然後還有一個初學者容易懵逼的：

這玩意，並不是平衡二叉樹。上代碼：

1//GO
 2func isBalanced(root *TreeNode) bool {
 3    if root == nil {
 4        return true
 5    }
 6    l := maxDepth(root.Left)
 7    r := maxDepth(root.Right)
 8    if abs(l-r)>1 {
 9        return false
10    }
11    if isBalanced(root.Left){
12        return true
13    }
14    return isBalanced(root.Right)
15}
16
17func maxDepth(root *TreeNode) int {
18    if root == nil {
19        return 0
20    }
21    return max(maxDepth(root.Left),maxDepth(root.Right)) + 1
22}
23
24func max(a,b int) int {
25    if a > b {
26        return a
27    }
28    return b
29}
30
31func abs(a int) int {
32    if a < 0 {
33        return -a
34    }
35    return a 
36}

08 PART

完全二叉樹

還有啥特殊的，要撈出來講一講的？

第222題：給出一個完全二叉樹，求出該樹的節點個數。

說明：

完全二叉樹的定義如下：在完全二叉樹中，除了最底層節點可能沒填滿外，其餘每層節點數都達到最大值，並且最下面一層的節點都集中在該層最左邊的若干位置。若最底層爲第 h 層，則該層包含 1~ 2h 個節點。

示例:

輸入:

/ \

2 3

/ \ /

4 5 6

輸出: 6

老樣子，我們得說說啥是完全二叉樹。完全二叉樹由滿二叉樹引出，先來了解一下什麼是滿二叉樹。如果二叉樹中除了葉子結點，每個結點的度都爲 2，則此二叉樹稱爲滿二叉樹。（二叉樹的度代表某個結點的孩子或者說直接後繼的個數，這個在上面已經說過了。對於二叉樹而言，1度是隻有一個孩子或者說單子樹，2度是有兩個孩子或者說左右子樹都有。）

那什麼又是完全二叉樹呢：如果二叉樹中除去最後一層節點爲滿二叉樹，且最後一層的結點依次從左到右分佈，則此二叉樹被稱爲完全二叉樹。比如下面這顆：

這個就不是：

上面做了這麼多題了，你應該能想到我要說啥 --- 遞歸。二叉樹的題目基本上都可以遞歸求解。

1func countNodes(root *TreeNode) int {
2    if root != nil {
3        return 0
4
5    }
6    return 1 + countNodes(root.Right) + countNodes(root.Left)
7}

但是很明顯，出題者肯定不是要這種答案。因爲這種答案和完全二叉樹一毛錢關係都沒有。所以我們繼續思考。

由於題中已經告訴我們這是一顆完全二叉樹，我們又已知了完全二叉樹除了最後一層，其他層都是滿的，並且最後一層的節點全部靠向了左邊。那我們可以想到，可以將該完全二叉樹可以分割成若幹滿二叉樹和完全二叉樹，滿二叉樹直接根據層高h計算出節點爲2^h-1，然後繼續計算子樹中完全二叉樹節點。那如何分割成若干滿二叉樹和完全二叉樹呢？對任意一個子樹，遍歷其左子樹層高left，右子樹層高right，相等左子樹則是滿二叉樹，否則右子樹是滿二叉樹。這裏可能不容易理解，我們看圖。

假如我們有樹如下：

我們看到根節點的左右子樹高度都爲3，那麼說明左子樹是一顆滿二叉樹。因爲節點已經填充到右子樹了，左子樹必定已經填滿了。所以左子樹的節點總數我們可以直接得到，是2^left - 1，加上當前這個root節點，則正好是2^3，即 8。然後只需要再對右子樹進行遞歸統計即可。

那假如我們的樹是這樣：

我們看到左子樹高度爲3，右子樹高度爲2。說明此時最後一層不滿，但倒數第二層已經滿了，可以直接得到右子樹的節點個數。同理，右子樹節點+root節點，總數爲2^right，即2^2。再對左子樹進行遞歸查找。

根據分析，得出代碼：

/java

lass Solution {
public int countNodes(TreeNode root) {
if (root == null) {
return 0;
}
int left = countLevel(root.left);
int right = countLevel(root.right);
if (left == right) {
return countNodes(root.right) + (1 << left);
} else {
return countNodes(root.left) + (1 << right);
}
}

private int countLevel(TreeNode root) {
int level = 0;
while (root != null) {
level++;
root = root.left;
}
return level;
}

09 PART

二叉樹的剪枝

該講的都講了，突然想到忘了一個經典操作 - 剪枝。迅速補上！非常重要！這裏額外說一點，就本人而言，對這個操作以及其衍化形式的使用會比較頻繁。因爲我是做反欺詐的，機器學習裏有一個概念叫做決策樹，那如果一顆決策樹完全生長，就會帶來比較大的過擬合問題。因爲完全生長的決策樹，每個節點只會包含一個樣本。所以我們就需要對決策樹進行剪枝操作，來提升整個決策模型的泛化能力... 聽不懂也沒關係，簡單點講，就是我覺得這個很重要，或者每道算法題都很重要。如果你在工作中沒有用到，不是說明算法不重要，而可能是你還不夠重要。

第814題：給定二叉樹根結點 root ，此外樹的每個結點的值要麼是 0，要麼是 1。返回移除了所有不包含 1 的子樹的原二叉樹。

( 節點 X 的子樹爲 X 本身，以及所有 X 的後代。)

示例1:

輸入: [1,null,0,0,1]

輸出: [1,null,0,null,1]

解釋:

只有紅色節點滿足條件“所有不包含 1 的子樹”。

右圖爲返回的答案。

示例2:

輸入: [1,0,1,0,0,0,1]

輸出: [1,null,1,null,1]

示例3:

輸入: [1,1,0,1,1,0,1,0]

輸出: [1,1,0,1,1,null,1]

說明:

給定的二叉樹最多有 100 個節點。

每個節點的值只會爲 0 或 1 。

還是先解釋一下，啥是剪枝：假設有一棵樹，最上層的是root節點，而父節點會依賴子節點。如果現在有一些節點已經標記爲無效，我們要刪除這些無效節點。如果無效節點的依賴的節點還有效，那麼不應該刪除，如果無效節點和它的子節點都無效，則可以刪除。剪掉這些節點的過程，稱爲剪枝，目的是用來處理二叉樹模型中的依賴問題。

說了好多遍了，二叉樹的問題，大多都可以通過遞歸進行求解。直接分析。假設我們有二叉樹如下：[0,1,0,1,0,0,0,0,1,1,0,1,0]：

長這樣：

剪枝之後是這樣：

剪什麼大家應該都能理解。那關鍵是怎麼剪？過程也很簡單，在遞歸的過程中，如果當前結點的左右節點皆爲空，且當前結點爲0，我們就將當前節點剪掉即可。

其實很簡單，直接看代碼：

1func pruneTree(root *TreeNode) *TreeNode {
 2    return deal(root)
 3}
 4
 5func deal(node *TreeNode) *TreeNode {
 6    if node == nil {
 7        return nil
 8    }
 9    node.Left = deal(node.Left)
10    node.Right = deal(node.Right)
11    if node.Left == nil && node.Right == nil && node.Val == 0 {
12        return nil
13    }
14    return node
15}

10 PART

囉嗦一下

二叉樹入門整合系列篇到這裏就完事了，相信大家如果可以完整看完，一定會有所收穫。但是呢，其實大家可以看到，上面的系列還有很多內容沒有講。比如很核心的一塊DFS和回溯。這些都會在後面出單獨的系列進行講解，希望大家多多支持！

今天的整合篇去除了之前的一些冗餘內容，對部分圖解也進行了重構，熬夜整合，猝死邊緣。

萬字長文！二叉樹入門和刷題看這篇就夠了！

01

PART

二叉樹是啥

02

PART

二叉樹最大深度

03

PART

二叉樹的層次遍歷

04

PART

二叉搜索樹

05

PART

BST的查找

06

PART

BST的刪除

07

PART

平衡二叉樹

08

PART

完全二叉樹

09

PART

二叉樹的剪枝

10

PART

囉嗦一下

工作中用到的腳本合集

24-5-18 X

Exchange刪除郵件

程序員硬核“年終大掃除”，清理了數據庫 70GB 空間

go-zero 編寫項目（微服務架構）的思路

保姆級 tomcat 快速入門

百度基礎面試題1-10

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結