二叉树与递归

àì夳堔傛蜴生んèń 2024-02-19 13:29 78阅读 0赞

104.[\[LeetCode\] Maximum Depth of Binary Tree 二叉树的最大深度][LeetCode_ Maximum Depth of Binary Tree]

给定一个二叉树，找出其最大深度。

二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。

**说明:** 叶子节点是指没有子节点的节点。

**示例：**  
给定二叉树 `[3,9,20,null,null,15,7]`，

3
       / \
      9  20
        /  \
       15   7

返回它的最大深度 3 。

class Solution \{  
public:  
int maxDepth(TreeNode\* root) \{  
if(!root)return 0;  
return 1+max(maxDepth(root->left),maxDepth(root->right));  
\}  
\};

111.[\[LeetCode\] Minimum Depth of Binary Tree 二叉树的最小深度][LeetCode_ Minimum Depth of Binary Tree]

二叉树的经典问题之最小深度问题就是就最短路径的节点个数，还是用深度优先搜索DFS来完成，万能的递归啊。。。请看代码：

class Solution {
    public:
        int minDepth(TreeNode *root) {
            if (root == NULL) return 0;
            if (root->left == NULL && root->right == NULL) return 1;
            
            if (root->left == NULL) return minDepth(root->right) + 1;
            else if (root->right == NULL) return minDepth(root->left) + 1;
            else return 1 + min(minDepth(root->left), minDepth(root->right));
        }
        
    };

226.[\[LeetCode\] Invert Binary Tree 翻转二叉树][LeetCode_ Invert Binary Tree]

翻转一棵二叉树。

**示例：**

输入：

4
       /   \
      2     7
     / \   / \
    1   3 6   9

输出：

4
       /   \
      7     2
     / \   / \
    9   6 3   1

class Solution \{  
public:  
//将根节点反转，并获取翻转后该根节点的指针  
TreeNode\* invertTree(TreeNode\* root) \{  
if(root == NULL)\{  
return NULL;  
\}else\{  
//这样做将：树的底层先被真正交换，然后其上一层才做反转  
TreeNode\* newleft = invertTree(root->right);  
TreeNode\* newright = invertTree(root->left);  
root->left = newleft;  
root->right = newright;  
return root;  
\}  
\}  
\};  
101.[\[LeetCode\] Symmetric Tree 判断对称树][LeetCode_ Symmetric Tree]

给定一个二叉树，检查它是否是镜像对称的。

例如，二叉树 `[1,2,2,3,4,4,3]` 是对称的。

1
       / \
      2   2
     / \ / \
    3  4 4  3

但是下面这个 `[1,2,2,null,3,null,3]` 则不是镜像对称的:

1
       / \
      2   2
       \   \
       3    3

**说明:**

如果你可以运用递归和迭代两种方法解决这个问题，会很加分。

判断二叉树是否是平衡树，比如有两个节点n1, n2，我们需要比较n1的左子节点的值和n2的右子节点的值是否相等，同时还要比较n1的右子节点的值和n2的左子结点的值是否相等，以此类推比较完所有的左右两个节点。我们可以用递归和迭代两种方法来实现，写法不同，但是算法核心都一样。

递归方法 (Recursive Solution)：

![复制代码][copycode.gif]

/**
     * Definition for binary tree
     * struct TreeNode {
     *     int val;
     *     TreeNode *left;
     *     TreeNode *right;
     *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
     * };
     */
    class Solution {
    public:
        bool isSymmetric(TreeNode *root) {
            if (!root) return true;
            return isSymmetric(root->left, root->right);
        }
        bool isSymmetric(TreeNode *left, TreeNode *right) {
            if (!left && !right) return true;
            if (left && !right || !left && right || left->val != right->val) return false;
            return isSymmetric(left->left, right->right) && isSymmetric(left->right, right->left);
        }
        
    };

222.[\[LeetCode\] Count Complete Tree Nodes 求完全二叉树的节点个数][LeetCode_ Count Complete Tree Nodes]

给出一个**完全二叉树**，求出该树的节点个数。

**说明：**

[完全二叉树][Link 1]的定义如下：在完全二叉树中，除了最底层节点可能没填满外，其余每层节点数都达到最大值，并且最下面一层的节点都集中在该层最左边的若干位置。若最底层为第 h 层，则该层包含 1~ 2h 个节点。

**示例:**

输入: 
        1
       / \
      2   3
     / \  /
    4  5 6
    
    输出: 6

对于一颗二叉树，假设其深度为d（d>1）。除了第d层外，其它各层的节点数目均已达最大值，且第d层所有节点从左向右连续地紧密排列，这样的二叉树被称为完全二叉树；

换句话说，完全二叉树从根结点到倒数第二层满足完美二叉树，最后一层可以不完全填充，其叶子结点都靠左对齐。

[完美二叉树 (Perfect Binary Tree)][_Perfect Binary Tree]：

A Perfect Binary Tree(PBT) is a tree with all leaf nodes at the same depth. All internal nodes have degree 2.

二叉树的第i层至多拥有![2^\{i-1\}][2_i-1]个节点数；深度为k的二叉树至多总共有![\{\\displaystyle 2^\{\\begin\{aligned\}k+1\\end\{aligned\}\}-1\}][displaystyle 2_begin_aligned_k_1_end_aligned_-1]个节点数，而总计拥有节点数匹配的，称为“满二叉树”；

[完满二叉树 (Full Binary Tree):][_Full Binary Tree]

A Full Binary Tree (FBT) is a tree in which every node other than the leaves has two children.

换句话说，所有非叶子结点的度都是2。（只要你有孩子，你就必然是有两个孩子。）

[500 × 200 - zy.swust.net.cn][500 _ 200 - zy.swust.net.cn]

通过上面的定义，我们可以看出二者的关系是，完美二叉树一定是完全二叉树，而完全二叉树不一定是完美二叉树。那么这道题给的完全二叉树就有可能是完美二叉树，若是完美二叉树，节点个数很好求，为2的h次方-1，h为该完美二叉树的高度。这道题可以用递归和非递归两种方法来解。我们先来看递归的方法，思路是分别找出以当前节点为根节点的左子树和右子树的高度并对比，如果相等，则说明是满二叉树，直接返回节点个数，如果不相等，则节点个数为左子树的节点个数加上右子树的节点个数再加1(根节点)，其中左右子树节点个数的计算可以使用递归来计算，参见代码如下：

![复制代码][copycode.gif]

class Solution {
    public:
        int countNodes(TreeNode* root) {
            int hLeft = 0, hRight = 0;
            TreeNode *pLeft = root, *pRight = root;
            while (pLeft) {
                ++hLeft;
                pLeft = pLeft->left;
            }
            while (pRight) {
                ++hRight;
                pRight = pRight->right;
            }
            if (hLeft == hRight) return pow(2, hLeft) - 1;
            return countNodes(root->left) + countNodes(root->right) + 1;
        }
    };

![复制代码][copycode.gif]

递归的解法还有一种解法如下所示：

![复制代码][copycode.gif]

class Solution {
    public:
        int countNodes(TreeNode* root) {
            int hLeft = leftHeight(root);
            int hRight = rightHeight(root);
            if (hLeft == hRight) return pow(2, hLeft) - 1;
            return countNodes(root->left) + countNodes(root->right) + 1;
        }
        int leftHeight(TreeNode* root) {
            if (!root) return 0;
            return 1 + leftHeight(root->left);
        }
        int rightHeight(TreeNode* root) {
            if (!root) return 0;
            return 1 + rightHeight(root->right);
        }
    };

110.[\[LeetCode\] Balanced Binary Tree 平衡二叉树][LeetCode_ Balanced Binary Tree]

给定一个二叉树，判断它是否是高度平衡的二叉树。

本题中，一棵高度平衡二叉树定义为：

> 一个二叉树*每个节点* 的左右两个子树的高度差的绝对值不超过1。

**示例 1:**

给定二叉树 `[3,9,20,null,null,15,7]`

3
       / \
      9  20
        /  \
       15   7

返回 `true` 。  
  
**示例 2:**

给定二叉树 `[1,2,2,3,3,null,null,4,4]`

1
          / \
         2   2
        / \
       3   3
      / \
     4   4

返回 `false` 。

求二叉树是否平衡，根据题目中的定义，高度平衡二叉树是每一个结点的两个子树的深度差不能超过1，那么我们肯定需要一个求各个点深度的函数，然后对每个节点的两个子树来比较深度差，时间复杂度为O(NlgN)，代码如下：

解法一：

class Solution {
    public:
        bool isBalanced(TreeNode *root) {
            if (!root) return true;
            if (abs(getDepth(root->left) - getDepth(root->right)) > 1) return false;
            return isBalanced(root->left) && isBalanced(root->right);    
        }
        int getDepth(TreeNode *root) {
            if (!root) return 0;
            return 1 + max(getDepth(root->left), getDepth(root->right));
        }
    };

上面那个方法正确但不是很高效，因为每一个点都会被上面的点计算深度时访问一次，我们可以进行优化。方法是如果我们发现子树不平衡，则不计算具体的深度，而是直接返回-1。那么优化后的方法为：对于每一个节点，我们通过checkDepth方法递归获得左右子树的深度，如果子树是平衡的，则返回真实的深度，若不平衡，直接返回-1，此方法时间复杂度O(N)，空间复杂度O(H)，参见代码如下：

解法二：

class Solution {
    public:    
        bool isBalanced(TreeNode *root) {
            if (checkDepth(root) == -1) return false;
            else return true;
        }
        int checkDepth(TreeNode *root) {
            if (!root) return 0;
            int left = checkDepth(root->left);
            if (left == -1) return -1;
            int right = checkDepth(root->right);
            if (right == -1) return -1;
            int diff = abs(left - right);
            if (diff > 1) return -1;
            else return 1 + max(left, right);
        }
    };

112[\[LeetCode\] Path Sum 二叉树的路径和][LeetCode_ Path Sum]

给定一个二叉树和一个目标和，判断该树中是否存在根节点到叶子节点的路径，这条路径上所有节点值相加等于目标和。

**说明:** 叶子节点是指没有子节点的节点。

**示例:**  
给定如下二叉树，以及目标和 `sum = 22`，

5
                 / \
                4   8
               /   / \
              11  13  4
             /  \      \
            7    2      1

返回 `true`, 因为存在目标和为 22 的根节点到叶子节点的路径 `5->4->11->2`。

道求二叉树的路径需要用深度优先算法DFS的思想来遍历每一条完整的路径，也就是利用递归不停找子节点的左右子节点，而调用递归函数的参数只有当前节点和sum值。首先，如果输入的是一个空节点，则直接返回false，如果如果输入的只有一个根节点，则比较当前根节点的值和参数sum值是否相同，若相同，返回true，否则false。 这个条件也是递归的终止条件。下面我们就要开始递归了，由于函数的返回值是Ture/False，我们可以同时两个方向一起递归，中间用或||连接，只要有一个是True，整个结果就是True。递归左右节点时，这时候的sum值应该是原sum值减去当前节点的值。代码如下：

class Solution {
    public:
        bool hasPathSum(TreeNode *root, int sum) {
            if (root == NULL) return false;
            if (root->left == NULL && root->right == NULL && root->val == sum ) return true;
            return hasPathSum(root->left, sum - root->val) || hasPathSum(root->right, sum - root->val);
        }
    };

.257.[\[LeetCode\] Binary Tree Paths 二叉树路径][LeetCode_ Binary Tree Paths]

给定一个二叉树，返回所有从根节点到叶子节点的路径。

**说明:** 叶子节点是指没有子节点的节点。

**示例:**

输入:
    
       1
     /   \
    2     3
     \
      5
    
    输出: ["1->2->5", "1->3"]
    
    解释: 所有根节点到叶子节点的路径为: 1->2->5, 1->3

这道题给我们一个二叉树，让我们返回所有根到叶节点的路径，跟之前那道[Path Sum II][]很类似，比那道稍微简单一些，不需要计算路径和，只需要无脑返回所有的路径即可，那么思路还是用递归来解，博主之前就强调过，玩树的题目，十有八九都是递归，而递归的核心就是不停的DFS到叶结点，然后在回溯回去。在递归函数中，当我们遇到叶结点的时候，即没有左右子结点，那么此时一条完整的路径已经形成了，我们加上当前的叶结点后存入结果res中，然后回溯。注意这里结果res需要reference，而out是不需要引用的，不然回溯回去还要删除新添加的结点，很麻烦。为了减少判断空结点的步骤，我们在调用递归函数之前都检验一下非空即可，代码而很简洁，参见如下：

解法一：

class Solution {
    public:
        vector<string> binaryTreePaths(TreeNode* root) {
            vector<string> res;
            if (root) helper(root, "", res);
            return res;
        }
        void helper(TreeNode* node, string out, vector<string>& res) {
            if (!node->left && !node->right) res.push_back(out + to_string(node->val));
            if (node->left) helper(node->left, out + to_string(node->val) + "->", res);
            if (node->right) helper(node->right, out + to_string(node->val) + "->", res);
        }
    };

下面再来看一种递归的方法，这个方法直接在一个函数中完成递归调用，不需要另写一个helper函数，核心思想和上面没有区别，参见代码如下：

解法二：

class Solution {
    public:
        vector<string> binaryTreePaths(TreeNode* root) {
            if (!root) return {};
            if (!root->left && !root->right) return {to_string(root->val)};
            vector<string> left = binaryTreePaths(root->left);
            vector<string> right = binaryTreePaths(root->right);
            left.insert(left.end(), right.begin(), right.end());
            for (auto &a : left) {
                a = to_string(root->val) + "->" + a;
            }
            return left;
        }
    };

113.[\[LeetCode\] Path Sum II 二叉树路径之和之二][LeetCode_ Path Sum II]

给定一个二叉树和一个目标和，找到所有从根节点到叶子节点路径总和等于给定目标和的路径。

**说明:** 叶子节点是指没有子节点的节点。

**示例:**  
给定如下二叉树，以及目标和 `sum = 22`，

5
                 / \
                4   8
               /   / \
              11  13  4
             /  \    / \
            7    2  5   1

[
       [5,4,11,2],
       [5,8,4,5]
    ]

这道二叉树路径之和在之前的基础上又需要找出路径 (可以参见我之前的博客 [http://www.cnblogs.com/grandyang/p/4036961.html][http_www.cnblogs.com_grandyang_p_4036961.html])，但是基本思想都一样，还是需要用深度优先搜索DFS，只不过数据结构相对复杂一点，需要用到二维的vector，而且每当DFS搜索到新节点时，都要保存该节点。而且每当找出一条路径之后，都将这个保存为一维vector的路径保存到最终结果二位vector中。并且，每当DFS搜索到子节点，发现不是路径和时，返回上一个结点时，需要把该节点从一维vector中移除。代码如下：

解法一：

![复制代码][copycode.gif]

class Solution {
    public:
        vector<vector<int> > pathSum(TreeNode *root, int sum) {
            vector<vector<int>> res;
            vector<int> out;
            helper(root, sum, out, res);
            return res;
        }
        void helper(TreeNode* node, int sum, vector<int>& out, vector<vector<int>>& res) {
            if (!node) return;
            out.push_back(node->val);
            if (sum == node->val && !node->left && !node->right) {
                res.push_back(out);
            }
            helper(node->left, sum - node->val, out, res);
            helper(node->right, sum - node->val, out, res);
            out.pop_back();
        }
    };

![复制代码][copycode.gif]

下面这种方法是迭代的写法，用的是中序遍历的顺序，参考之前那道[Binary Tree Inorder Traversal][]，中序遍历本来是要用栈来辅助运算的，由于我们要取出路径上的节点值，所以我们用一个vector来代替stack，首先利用while循环找到最左子节点，在找的过程中，把路径中的节点值都加起来，这时候我们取出vector中的尾元素，如果其左右子节点都不存在且当前累加值正好等于sum了，我们将这条路径取出来存入结果res中，下面的部分是和一般的迭代中序写法有所不同的地方，因为如果当前最左节点已经是个叶节点了，我们要转移到其他的节点上时需要把当前的节点值减去，而如果当前最左节点不是叶节点，下面还有一个右子节点，这时候移动指针时就不能减去当前节点值，为了区分这两种情况，我们需要用一个额外指针pre来指向前一个节点，如果右子节点存在且不等于pre，我们直接将指针移到右子节点，反之我们更新pre为cur，cur重置为空，val减去当前节点，s删掉最后一个节点，参见代码如下：

解法二：

![复制代码][copycode.gif]

class Solution {
    public:
        vector<vector<int> > pathSum(TreeNode *root, int sum) {
            vector<vector<int>> res;
            vector<TreeNode*> s;
            TreeNode *cur = root, *pre = NULL;
            int val = 0;
            while (cur || !s.empty()) {
                while (cur) {
                    s.push_back(cur);
                    val += cur->val;
                    cur = cur->left;
                }
                cur = s.back(); 
                if (!cur->left && !cur->right && val == sum) {
                    vector<int> v;
                    for (auto it : s) {
                        v.push_back(it->val);
                    }
                    res.push_back(v);
                }
                if (cur->right && cur->right != pre) cur = cur->right;
                else {
                    pre = cur;
                    val -= cur->val;
                    s.pop_back();
                    cur = NULL;
                }
            }
            return res;
        }
    };

129.[\[LeetCode\] Sum Root to Leaf Numbers 求根到叶节点数字之和][LeetCode_ Sum Root to Leaf Numbers]

给定一个二叉树，它的每个结点都存放一个 `0-9` 的数字，每条从根到叶子节点的路径都代表一个数字。

例如，从根到叶子节点路径 `1->2->3` 代表数字 `123`。

计算从根到叶子节点生成的所有数字之和。

**说明:** 叶子节点是指没有子节点的节点。

**示例 1:**

输入: [1,2,3]
        1
       / \
      2   3
    输出: 25
    解释:
    从根到叶子节点路径 1->2 代表数字 12.
    从根到叶子节点路径 1->3 代表数字 13.
    因此，数字总和 = 12 + 13 = 25.

**示例 2:**

输入: [4,9,0,5,1]
        4
       / \
      9   0
     / \
    5   1
    输出: 1026
    解释:
    从根到叶子节点路径 4->9->5 代表数字 495.
    从根到叶子节点路径 4->9->1 代表数字 491.
    从根到叶子节点路径 4->0 代表数字 40.
    因此，数字总和 = 495 + 491 + 40 = 1026.

这道求根到叶节点数字之和的题跟之前的求[Path Sum 二叉树的路径和][http_www.cnblogs.com_grandyang_p_4036961.html]很类似，都是利用DFS递归来解，这道题由于不是单纯的把各个节点的数字相加，而是每到一个新的数字，要把原来的数字扩大10倍之后再相加。代码如下：

![复制代码][copycode.gif]

/**
     * Definition for binary tree
     * struct TreeNode {
     *     int val;
     *     TreeNode *left;
     *     TreeNode *right;
     *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
     * };
     */
    class Solution {
    public:
        int sumNumbers(TreeNode *root) {
            return sumNumbersDFS(root, 0);
        }
        int sumNumbersDFS(TreeNode *root, int sum) {
            if (!root) return 0;
            sum = sum * 10 + root->val;
            if (!root->left && !root->right) return sum;
            return sumNumbersDFS(root->left, sum) + sumNumbersDFS(root->right, sum);
        }
    };

437.[\[LeetCode\] Path Sum III 二叉树的路径和之三][LeetCode_ Path Sum III]

给定一个二叉树，它的每个结点都存放着一个整数值。

找出路径和等于给定数值的路径总数。

路径不需要从根节点开始，也不需要在叶子节点结束，但是路径方向必须是向下的（只能从父节点到子节点）。

二叉树不超过1000个节点，且节点数值范围是 \[-1000000,1000000\] 的整数。

**示例：**

root = [10,5,-3,3,2,null,11,3,-2,null,1], sum = 8
    
          10
         /  \
        5   -3
       / \    \
      3   2   11
     / \   \
    3  -2   1
    
    返回 3。和等于 8 的路径有:
    
    1.  5 -> 3
    2.  5 -> 2 -> 1
    3.  -3 -> 11

这道题让我们求二叉树的路径的和等于一个给定值，说明了这条路径不必要从根节点开始，可以是中间的任意一段，而且二叉树的节点值也是有正有负。那么我们可以用递归来做，相当于先序遍历二叉树，对于每一个节点都有记录了一条从根节点到当前节点到路径，同时用一个变量curSum记录路径节点总和，然后我们看curSum和sum是否相等，相等的话结果res加1，不等的话我们来继续查看子路径和有没有满足题意的，做法就是每次去掉一个节点，看路径和是否等于给定值，注意最后必须留一个节点，不能全去掉了，因为如果全去掉了，路径之和为0，而如果假如给定值刚好为0的话就会有问题，整体来说不算一道很难的题，参见代码如下：

class Solution \{  
public:  
int pathSum(TreeNode\* root, int sum) \{  
if(root==NULL)return 0;  
int res=findpath(root,sum);  
res+=pathSum(root->left,sum);  
res+=pathSum(root->right,sum);  
return res;  
\}  
private:  
int findpath(TreeNode\* node,int num)  
\{  
if(node==NULL)return 0;  
int res=0;  
if(node->val==num)res+=1;  
res+=findpath(node->left,num-node->val);  
res+=findpath(node->right,num-node->val);  
return res;  
\}  
\};

235.[\[LeetCode\] Lowest Common Ancestor of a Binary Search Tree 二叉搜索树的最小共同父节点][LeetCode_ Lowest Common Ancestor of a Binary Search Tree]

定一个二叉搜索树, 找到该树中两个指定节点的最近公共祖先。

[百度百科][Link 2]中最近公共祖先的定义为：“对于有根树 T 的两个结点 p、q，最近公共祖先表示为一个结点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大（**一个节点也可以是它自己的祖先**）。”

例如，给定如下二叉搜索树: root = \[6,2,8,0,4,7,9,null,null,3,5\]

_______6______
           /              \
        ___2__          ___8__
       /      \        /      \
       0      _4       7       9
             /  \
             3   5

**示例 1:**

输入: root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 8
    输出: 6 
    解释: 节点 2 和节点 8 的最近公共祖先是 6。

**示例 2:**

输入: root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 4
    输出: 2
    解释: 节点 2 和节点 4 的最近公共祖先是 2, 因为根据定义最近公共祖先节点可以为节点本身。

**说明:**

*  所有节点的值都是唯一的。
 *  p、q 为不同节点且均存在于给定的二叉搜索树中。

class Solution \{  
public:  
TreeNode\* lowestCommonAncestor(TreeNode\* root, TreeNode\* p, TreeNode\* q) \{  
assert(p!=NULL&&q!=NULL);  
if(root==NULL)return NULL;  
if(p->val<root->val&&q->val<root->val)  
return lowestCommonAncestor(root->left,p,q);  
if(p->val>root->val&&q->val>root->val)  
return lowestCommonAncestor(root->right,p,q);  
  
return root;  
\}  
\};

98.[\[LeetCode\] Validate Binary Search Tree 验证二叉搜索树][LeetCode_ Validate Binary Search Tree]

给定一个二叉树，判断其是否是一个有效的二叉搜索树。

假设一个二叉搜索树具有如下特征：

*  节点的左子树只包含**小于**当前节点的数。
 *  节点的右子树只包含**大于**当前节点的数。
 *  所有左子树和右子树自身必须也是二叉搜索树。

**示例 1:**

输入:
        2
       / \
      1   3
    输出: true

**示例 2:**

输入:
        5
       / \
      1   4
         / \
        3   6
    输出: false
    解释: 输入为: [5,1,4,null,null,3,6]。
         根节点的值为 5 ，但是其右子节点值为 4 。

这道验证二叉搜索树有很多种解法，可以利用它本身的性质来做，即左<根<右，也可以通过利用中序遍历结果为有序数列来做，下面我们先来看最简单的一种，就是利用其本身性质来做，初始化时带入系统最大值和最小值，在递归过程中换成它们自己的节点值，用long代替int就是为了包括int的边界条件，代码如下：

class Solution {
    public:
        bool isValidBST(TreeNode *root) {
            return isValidBST(root, LONG_MIN, LONG_MAX);
        }
        bool isValidBST(TreeNode *root, long mn, long mx) {
            if (!root) return true;
            if (root->val <= mn || root->val >= mx) return false;
            return isValidBST(root->left, mn, root->val) && isValidBST(root->right, root->val, mx);
        }
    };

450.[\[LeetCode\] Delete Node in a BST 删除二叉搜索树中的节点][LeetCode_ Delete Node in a BST]

我们先来看一种递归的解法，首先判断根节点是否为空。

由于BST的左<根<右的性质，使得我们可以快速定位到要删除的节点，我们对于当前节点值不等于key的情况，根据大小关系对其左右子节点分别调用递归函数。若当前节点就是要删除的节点，我们首先判断是否有一个子节点不存在，那么我们就将root指向另一个节点，如果左右子节点都不存在，那么root就赋值为空了，也正确。难点就在于处理左右子节点都存在的情况，我们需要在右子树找到最小值，即右子树中最左下方的节点，然后将该最小值赋值给root，然后再在右子树中调用递归函数来删除这个值最小的节点，参见代码如下：

解法一：

class Solution {
    public:
        TreeNode* deleteNode(TreeNode* root, int key) {
            if (!root) return NULL;
            if (root->val > key) {
                root->left = deleteNode(root->left, key);
            } else if (root->val < key) {
                root->right = deleteNode(root->right, key);
            } else {
                if (!root->left || !root->right) {
                    root = (root->left) ? root->left : root->right;
                } else {
                    TreeNode *cur = root->right;
                    while (cur->left) cur = cur->left;
                    root->val = cur->val;
                    root->right = deleteNode(root->right, cur->val);
                }
            }
            return root;
        }
    };

下面来看一种对于二叉树通用的解法，适用于所有二叉树，所以并没有利用BST的性质，而是遍历了所有的节点，然后删掉和key值相同的节点，参见代码如下：

解法三：

class Solution {
    public:
        TreeNode* deleteNode(TreeNode* root, int key) {
            if (!root) return NULL;
            if (root->val == key) {
                if (!root->right) return root->left;
                else {
                    TreeNode *cur = root->right;
                    while (cur->left) cur = cur->left;
                    swap(root->val, cur->val);
                }
            }
            root->left = deleteNode(root->left, key);
            root->right = deleteNode(root->right, key);
            return root;
        }
    };

108.[\[LeetCode\] Convert Sorted Array to Binary Search Tree 将有序数组转为二叉搜索树][LeetCode_ Convert Sorted Array to Binary Search Tree]

这道题是要将有序数组转为二叉搜索树，所谓[二叉搜索树][Link 3]，是一种始终满足左<根<右的特性，如果将二叉搜索树按中序遍历的话，得到的就是一个有序数组了。那么反过来，我们可以得知，根节点应该是有序数组的中间点，从中间点分开为左右两个有序数组，在分别找出其中间点作为原中间点的左右两个子节点，这不就是是二分查找法的核心思想么。所以这道题考的就是二分查找法，代码如下：

class Solution {
    public:
        TreeNode *sortedArrayToBST(vector<int> &num) {
            return sortedArrayToBST(num, 0 , num.size() - 1);
        }
        TreeNode *sortedArrayToBST(vector<int> &num, int left, int right) {
            if (left > right) return NULL;
            int mid = (left + right) / 2;
            TreeNode *cur = new TreeNode(num[mid]);
            cur->left = sortedArrayToBST(num, left, mid - 1);
            cur->right = sortedArrayToBST(num, mid + 1, right);
            return cur;
        }
    };

230.[\[LeetCode\] Kth Smallest Element in a BST 二叉搜索树中的第K小的元素][LeetCode_ Kth Smallest Element in a BST _K]

这又是一道关于[二叉搜索树][Link 3] Binary Search Tree 的题， LeetCode中关于BST的题有[Validate Binary Search Tree 验证二叉搜索树][Validate Binary Search Tree]， [Recover Binary Search Tree 复原二叉搜索树][Recover Binary Search Tree]， [Binary Search Tree Iterator 二叉搜索树迭代器][Binary Search Tree Iterator]， [Unique Binary Search Trees 独一无二的二叉搜索树][Unique Binary Search Trees]， [Unique Binary Search Trees II 独一无二的二叉搜索树之二][Unique Binary Search Trees II]，[Convert Sorted Array to Binary Search Tree 将有序数组转为二叉搜索树][Convert Sorted Array to Binary Search Tree] 和 [Convert Sorted List to Binary Search Tree 将有序链表转为二叉搜索树][Convert Sorted List to Binary Search Tree]。

那么这道题给的提示是让我们用BST的性质来解题，最重要的性质是就是左<根<右，那么如果用中序遍历所有的节点就会得到一个有序数组。所以解题的关键还是中序遍历啊。关于二叉树的中序遍历可以参见我之前的博客[Binary Tree Inorder Traversal 二叉树的中序遍历][Binary Tree Inorder Traversal]，里面有很多种方法可以用，**我们先来看一种非递归的方法，中序遍历最先遍历到的是最小的结点，那么我们只要用一个计数器，每遍历一个结点，计数器自增1，当计数器到达k时，返回当前结点值即可**，参见代码如下：

解法一：

class Solution {
    public:
        int kthSmallest(TreeNode* root, int k) {
            int cnt = 0;
            stack<TreeNode*> s;
            TreeNode *p = root;
            while (p || !s.empty()) {
                while (p) {
                    s.push(p);
                    p = p->left;
                }
                p = s.top(); s.pop();
                ++cnt;
                if (cnt == k) return p->val;
                p = p->right;
            }
            return 0;
        }
    };

当然，此题我们也可以用递归来解，还是利用中序遍历来解，代码如下：

解法二：

class Solution {
    public:
        int kthSmallest(TreeNode* root, int k) {
            return kthSmallestDFS(root, k);
        }
        int kthSmallestDFS(TreeNode* root, int &k) {
            if (!root) return -1;
            int val = kthSmallestDFS(root->left, k);
            if (k == 0) return val;
            if (--k == 0) return root->val;
            return kthSmallestDFS(root->right, k);
        }
    };

再来看一种分治法的思路，由于BST的性质，我们可以快速定位出第k小的元素是在左子树还是右子树，我们首先计算出左子树的结点个数总和cnt，如果k小于等于左子树结点总和cnt，说明第k小的元素在左子树中，直接对左子结点调用递归即可。如果k大于cnt+1，说明目标值在右子树中，对右子结点调用递归函数，注意此时的k应为k-cnt-1，应为已经减少了cnt+1个结点。如果k正好等于cnt+1，说明当前结点即为所求，返回当前结点值即可，参见代码如下：

解法三：

class Solution {
    public:
        int kthSmallest(TreeNode* root, int k) {
            int cnt = count(root->left);
            if (k <= cnt) {
                return kthSmallest(root->left, k);
            } else if (k > cnt + 1) {
                return kthSmallest(root->right, k - cnt - 1);
            }
            return root->val;
        }
        int count(TreeNode* node) {
            if (!node) return 0;
            return 1 + count(node->left) + count(node->right);
        }
    };

236.[\[LeetCode\] Lowest Common Ancestor of a Binary Tree 二叉树的最小共同父节点][LeetCode_ Lowest Common Ancestor of a Binary Tree]

这道求二叉树的最小共同父节点的题是之前那道 [Lowest Common Ancestor of a Binary Search Tree][] 的Follow Up。跟之前那题不同的地方是，这道题是普通是二叉树，不是二叉搜索树，所以就不能利用其特有的性质，所以我们只能在二叉树中来搜索p和q，然后从路径中找到最后一个相同的节点即为父节点，我们可以用递归来实现，在递归函数中，我们首先看当前结点是否为空，若为空则直接返回空，若为p或q中的任意一个，也直接返回当前结点。否则的话就对其左右子结点分别调用递归函数，由于这道题限制了p和q一定都在二叉树中存在，那么如果当前结点不等于p或q，p和q要么分别位于左右子树中，要么同时位于左子树，或者同时位于右子树，那么我们分别来讨论：

若p和q要么分别位于左右子树中，那么对左右子结点调用递归函数，会分别返回p和q结点的位置，而当前结点正好就是p和q的最小共同父结点，直接返回当前结点即可，这就是题目中的例子1的情况。

若p和q同时位于左子树，这里有两种情况，一种情况是left会返回p和q中较高的那个位置，而right会返回空，所以我们最终返回非空的left即可，这就是题目中的例子2的情况。还有一种情况是会返回p和q的最小父结点，就是说当前结点的左子树中的某个结点才是p和q的最小父结点，会被返回。

若p和q同时位于右子树，同样这里有两种情况，一种情况是right会返回p和q中较高的那个位置，而left会返回空，所以我们最终返回非空的right即可，还有一种情况是会返回p和q的最小父结点，就是说当前结点的右子树中的某个结点才是p和q的最小父结点，会被返回，写法很简洁，代码如下：

解法一：

class Solution {
    public:
        TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
           if (!root || p == root || q == root) return root;
           TreeNode *left = lowestCommonAncestor(root->left, p, q);
           TreeNode *right = lowestCommonAncestor(root->right, p , q);
           if (left && right) return root;
           return left ? left : right;
        }
    };

上述代码可以进行优化一下，如果当前结点不为空，且既不是p也不是q，那么根据上面的分析，p和q的位置就有三种情况，p和q要么分别位于左右子树中，要么同时位于左子树，或者同时位于右子树。我们需要优化的情况就是当p和q同时为于左子树或右子树中，而且返回的结点并不是p或q，那么就是p和q的最小父结点了，已经求出来了，就不用再对右结点调用递归函数了，参见代码如下：

解法二：

class Solution {
    public:
        TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
           if (!root || p == root || q == root) return root;
           TreeNode *left = lowestCommonAncestor(root->left, p, q);
           if (left && left != p && left != q) return left;
           TreeNode *right = lowestCommonAncestor(root->right, p , q);
    　　　　if (left && right) return root;
           return left ? left : right;
        }
    };

[LeetCode_ Maximum Depth of Binary Tree]: https://www.cnblogs.com/grandyang/p/4051348.html
[LeetCode_ Minimum Depth of Binary Tree]: https://www.cnblogs.com/grandyang/p/4042168.html
[LeetCode_ Invert Binary Tree]: https://www.cnblogs.com/grandyang/p/4572877.html
[LeetCode_ Symmetric Tree]: https://www.cnblogs.com/grandyang/p/4051715.html
[copycode.gif]: https://image.dandelioncloud.cn/pgy_files/images/2024/01/29/b818ab911b004a27b56a6d6c8687430e.png
[LeetCode_ Count Complete Tree Nodes]: https://www.cnblogs.com/grandyang/p/4567827.html
[Link 1]: https://baike.baidu.com/item/%E5%AE%8C%E5%85%A8%E4%BA%8C%E5%8F%89%E6%A0%91/7773232?fr=aladdin
[_Perfect Binary Tree]: https://zh.wikipedia.org/wiki/%E4%BA%8C%E5%8F%89%E6%A0%91
[2_i-1]: https://wikimedia.org/api/rest_v1/media/math/render/svg/de838b503259acc792dd682654445984ea6e4c6d
[displaystyle 2_begin_aligned_k_1_end_aligned_-1]: https://wikimedia.org/api/rest_v1/media/math/render/svg/f24729d4eae59094b7ed114e09dcbf142f32cde8
[_Full Binary Tree]: http://www.cnblogs.com/idorax/p/6441043.html
[500 _ 200 - zy.swust.net.cn]: http://www.google.com/imgres?imgurl=http://zy.swust.net.cn/02/2/sjjg/images/chap06/C6P3.gif&imgrefurl=http://zy.swust.net.cn/02/2/sjjg/page/chap06/060201.asp&h=200&w=500&tbnid=ASz3gK5eek0jvM:&zoom=1&docid=u6zq2P7Qe63VCM&ei=JmR4VfHKOMPWsAWwn4LICw&tbm=isch&ved=0CCEQMygEMARqFQoTCPH1y7HEhcYCFUMrrAodsI8AuQ
[LeetCode_ Balanced Binary Tree]: https://www.cnblogs.com/grandyang/p/4045660.html
[LeetCode_ Path Sum]: https://www.cnblogs.com/grandyang/p/4036961.html
[LeetCode_ Binary Tree Paths]: https://www.cnblogs.com/grandyang/p/4738031.html
[Path Sum II]: http://www.cnblogs.com/grandyang/p/4042156.html
[LeetCode_ Path Sum II]: https://www.cnblogs.com/grandyang/p/4042156.html
[http_www.cnblogs.com_grandyang_p_4036961.html]: http://www.cnblogs.com/grandyang/p/4036961.html
[Binary Tree Inorder Traversal]: http://www.cnblogs.com/grandyang/p/4297300.html
[LeetCode_ Sum Root to Leaf Numbers]: https://www.cnblogs.com/grandyang/p/4273700.html
[LeetCode_ Path Sum III]: https://www.cnblogs.com/grandyang/p/6007336.html
[LeetCode_ Lowest Common Ancestor of a Binary Search Tree]: https://www.cnblogs.com/grandyang/p/4640572.html
[Link 2]: https://baike.baidu.com/item/%E6%9C%80%E8%BF%91%E5%85%AC%E5%85%B1%E7%A5%96%E5%85%88/8918834?fr=aladdin
[LeetCode_ Validate Binary Search Tree]: https://www.cnblogs.com/grandyang/p/4298435.html
[LeetCode_ Delete Node in a BST]: https://www.cnblogs.com/grandyang/p/6228252.html
[LeetCode_ Convert Sorted Array to Binary Search Tree]: https://www.cnblogs.com/grandyang/p/4295245.html
[Link 3]: http://zh.wikipedia.org/wiki/%E4%BA%8C%E5%85%83%E6%90%9C%E5%B0%8B%E6%A8%B9
[LeetCode_ Kth Smallest Element in a BST _K]: https://www.cnblogs.com/grandyang/p/4620012.html
[Validate Binary Search Tree]: http://www.cnblogs.com/grandyang/p/4298435.html
[Recover Binary Search Tree]: http://www.cnblogs.com/grandyang/p/4298069.html
[Binary Search Tree Iterator]: http://www.cnblogs.com/grandyang/p/4231455.html
[Unique Binary Search Trees]: http://www.cnblogs.com/grandyang/p/4299608.html
[Unique Binary Search Trees II]: http://www.cnblogs.com/grandyang/p/4301096.html
[Convert Sorted Array to Binary Search Tree]: http://www.cnblogs.com/grandyang/p/4295245.html
[Convert Sorted List to Binary Search Tree]: http://www.cnblogs.com/grandyang/p/4295618.html
[LeetCode_ Lowest Common Ancestor of a Binary Tree]: https://www.cnblogs.com/grandyang/p/4641968.html
[Lowest Common Ancestor of a Binary Search Tree]: http://www.cnblogs.com/grandyang/p/4640572.html