代码随想录（六）：二叉树

程序员小浩

已于 2023-08-01 10:23:04 修改

阅读量296

点赞数

分类专栏：代码随想录题解文章标签： leetcode 算法深度优先

于 2023-03-25 22:27:46 首次发布

本文链接：https://blog.csdn.net/weixin_45029883/article/details/129764724

版权

代码随想录题解专栏收录该内容

8 篇文章 0 订阅

订阅专栏

文章目录

144. 二叉树的前序遍历
94. 二叉树的中序遍历
145. 二叉树的后序遍历
102. 二叉树的层序遍历
226. 翻转二叉树
101. 对称二叉树
104. 二叉树的最大深度
559. N 叉树的最大深度
111. 二叉树的最小深度
222. 完全二叉树的节点个数
110. 平衡二叉树
257. 二叉树的所有路径
404. 左叶子之和
513. 找树左下角的值
112. 路径总和
105. 从前序与中序遍历序列构造二叉树
654. 最大二叉树
617. 合并二叉树
700. 二叉搜索树中的搜索
98. 验证二叉搜索树
530. 二叉搜索树的最小绝对差
501. 二叉搜索树中的众数
236. 二叉树的最近公共祖先
235. 二叉搜索树的最近公共祖先
701. 二叉搜索树中的插入操作
450. 删除二叉搜索树中的节点
669. 修剪二叉搜索树
108. 将有序数组转换为二叉搜索树
538. 把二叉搜索树转换为累加树

144. 二叉树的前序遍历

给你二叉树的根节点 root ，返回它节点值的 前序遍历 。

示例 1：

请添加图片描述
输入：root = [1,null,2,3]
输出：[1,2,3]

示例 2：

输入：root = []
输出：[]

示例 3：

输入：root = [1]
输出：[1]

示例 4：

请添加图片描述
输入：root = [1,2]
输出：[1,2]

提示：

树中节点数目在范围 [0, 100] 内
-100 <= Node.val <= 100

进阶：递归算法很简单，你可以通过 迭代算法 完成吗？

递归写法：

class Solution {
public:
    vector<int> res;

    vector<int> preorderTraversal(TreeNode* root) {
        dfs(root);
        return res;
    }

    void dfs(TreeNode* root) {
        if (!root) return;
        res.push_back(root->val);
        dfs(root->left);
        dfs(root->right);
    }
};

迭代写法：

class Solution {
public:
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> res;
        stack<TreeNode*> stk;
        while (root || stk.size()) {
            while (root) {
                res.push_back(root->val);
                stk.push(root);
                root = root->left;
            }
            root = stk.top()->right;
            stk.pop();
        }
        return res;
    }
};

94. 二叉树的中序遍历

给定一个二叉树的根节点 root ，返回它的 中序遍历 。

示例 1：

请添加图片描述
输入：root = [1,null,2,3]
输出：[1,3,2]

示例 2：

输入：root = []
输出：[]

示例 3：

输入：root = [1]
输出：[1]

提示：

树中节点数目在范围 [0, 100] 内
-100 <= Node.val <= 100

进阶: 递归算法很简单，你可以通过 迭代算法 完成吗？

递归写法：

class Solution {
public:
    vector<int> res;
    vector<int> inorderTraversal(TreeNode* root) {
        dfs(root);
        return res;
    }

    void dfs(TreeNode* root) {
        if (!root) return;
        dfs(root->left);
        res.push_back(root->val);
        dfs(root->right); 
    }
};

迭代写法：

class Solution {
public:
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> res;
        stack<TreeNode*> stk;

        while (root || stk.size()) {
            while (root) {
                stk.push(root);
                root = root->left;
            }

            root = stk.top();
            stk.pop();
            res.push_back(root->val);
            root = root->right;
        }

        return res;
    }
};

145. 二叉树的后序遍历

给你一棵二叉树的根节点 root ，返回其节点值的 后序遍历 。

示例 1：

请添加图片描述
输入：root = [1,null,2,3]
输出：[3,2,1]

示例 2：

输入：root = []
输出：[]

示例 3：

输入：root = [1]
输出：[1]

提示：

树中节点的数目在范围 [0, 100] 内
-100 <= Node.val <= 100

进阶：递归算法很简单，你可以通过 迭代算法 完成吗？

递归写法：

class Solution {
public:
    vector<int> res;

    vector<int> postorderTraversal(TreeNode* root) {
        dfs(root);
        return res;
    }

    void dfs(TreeNode* root) {
        if (!root) return;
        dfs(root->left);
        dfs(root->right);
        res.push_back(root->val);
    }
};

迭代写法：

class Solution {
public:
    vector<int> postorderTraversal(TreeNode* root) {
        vector<int> res;
        stack<TreeNode*> stk;
        while (root || stk.size()) {
            while (root) {
                res.push_back(root->val);
                stk.push(root);
                root = root->right;
            }

            root = stk.top()->left;
            stk.pop();
        }

        reverse(res.begin(), res.end());
        return res;
    }
};

102. 二叉树的层序遍历

给你二叉树的根节点 root ，返回其节点值的 层序遍历 。（即逐层地，从左到右访问所有节点）。

示例 1：

输入：root = [3,9,20,null,null,15,7]
输出：[[3],[9,20],[15,7]]

示例 2：

输入：root = [1]
输出：[[1]]

示例 3：

输入：root = []
输出：[]

提示：

树中节点数目在范围 [0, 2000] 内
-1000 <= Node.val <= 1000

解题思路：

(BFS) O(n)

宽度优先遍历，一层一层来做。

时间复杂度分析：树中每个节点仅会进队出队一次，所以时间复杂度是 O(n)。

C++代码：

class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>> res;
        queue<TreeNode*> q;
        if (root) q.push(root);

        while (q.size()) {
            vector<int> level; //用来保存当前层的元素
            int len = q.size(); //当前层的元素个数

            while (len -- ) {
                auto t = q.front();
                q.pop(); //将对头元素出队
                level.push_back(t->val); //取出对头元素放入当前层的数组中
                if (t->left) q.push(t->left); //将对头元素的左儿子入队
                if (t->right) q.push(t->right); //将对头元素的右儿子入队
            }
            res.push_back(level); //将当前层的数组保存在结果数组中
        }

        return res;
    }
};

226. 翻转二叉树

给你一棵二叉树的根节点 root ，翻转这棵二叉树，并返回其根节点。

示例 1：

请添加图片描述

输入：root = [4,2,7,1,3,6,9]
输出：[4,7,2,9,6,3,1]

示例 2：

请添加图片描述

输入：root = [2,1,3]
输出：[2,3,1]

示例 3：

输入：root = []
输出：[]

提示：

树中节点数目范围在 [0, 100] 内
-100 <= Node.val <= 100

递归写法：

class Solution {
public:
    TreeNode* invertTree(TreeNode* root) {
        if (!root) return nullptr;
        swap(root->left, root->right);
        invertTree(root->left);
        invertTree(root->right);
        return root;
    }
};

101. 对称二叉树

给你一个二叉树的根节点 root ，检查它是否轴对称。

示例 1：

请添加图片描述

输入：root = [1,2,2,3,4,4,3]
输出：true

示例 2：

在这里插入图片描述

输入：root = [1,2,2,null,3,null,3]
输出：false

提示：

树中节点数目在范围 [1, 1000] 内
-100 <= Node.val <= 100

进阶：你可以运用递归和迭代两种方法解决这个问题吗？

递归写法：

class Solution {
public:
    bool isSymmetric(TreeNode* root) {
        if (!root) return true;
        return dfs(root->left, root->right);
    }
    bool dfs(TreeNode* p, TreeNode* q) {
        if (!p && !q) return true;
        if (!p || !q || p->val != q->val) return false;
        return dfs(p->left, q->right) && dfs(p->right, q->left);
    }
};

104. 二叉树的最大深度

给定一个二叉树，找出其最大深度。
二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。

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

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

返回它的最大深度 3 。

递归遍历：

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

层序遍历：

class Solution {
public:
    int maxDepth(TreeNode* root) {
        if (!root) return 0;
        int depth = 0;
        queue<TreeNode*> q;
        q.push(root);
        while (q.size()) {
            depth++; //每遍历一层就将depth + 1
            int len = q.size();
            while (len--) {
                auto t = q.front();
                q.pop();
                if (t->left) q.push(t->left);
                if (t->right) q.push(t->right);
            }
        }
        return depth;
    }
};

559. N 叉树的最大深度

给定一个 N 叉树，找到其最大深度。
最大深度是指从根节点到最远叶子节点的最长路径上的节点总数。
N 叉树输入按层序遍历序列化表示，每组子节点由空值分隔（请参见示例）。

示例：

在这里插入图片描述

输入：root = [1,null,3,2,4,null,5,6]
输出：3

提示：

树的深度不会超过 1000 。
树的节点数目位于 [0, 10⁴] 之间。

递归遍历：

class Solution {
public:
    int maxDepth(Node* root) {
        if (!root) return 0;
        int res = 0;
        for (auto c: root->children) res = max(res, maxDepth(c));
        return res + 1;
    }
};

层序遍历：

class Solution {
public:
    int maxDepth(Node* root) {
        queue<Node*> q;
        if (!root) return 0;
        int res;
        q.push(root);
        while (q.size()) {
            int len = q.size();
            res++;
            while (len--) {
                auto t = q.front();
                q.pop();
                for (auto c : t->children) q.push(c);
            }
        }
        return res;
    }
};

111. 二叉树的最小深度

给定一个二叉树，找出其最小深度。
最小深度是从根节点到最近叶子节点的最短路径上的节点数量。

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

示例 1：

在这里插入图片描述

输入：root = [3,9,20,null,null,15,7]
输出：2

示例 2：

输入：root = [2,null,3,null,4,null,5,null,6]
输出：5

提示：

树中节点数的范围在 [0, 10⁵] 内
-1000 <= Node.val <= 1000

递归遍历：

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

层序遍历：

class Solution {
public:
    int minDepth(TreeNode* root) {
        queue<TreeNode*> q;
        int res = 0;
        if (root) q.push(root);
        while (q.size()) {
            int len = q.size();
            res++;
            while (len--) {
                auto t = q.front();
                q.pop();
                if (!t->left && !t->right) return res;
                if (t->left) q.push(t->left);
                if (t->right) q.push(t->right);
            }
        }
        return res;
    }
};

222. 完全二叉树的节点个数

给你一棵 完全二叉树 的根节点 root ，求出该树的节点个数。

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

示例 1：

在这里插入图片描述

输入：root = [1,2,3,4,5,6]
输出：6

示例 2：

输入：root = []
输出：0

示例 3：

输入：root = [1]
输出：1

提示：

树中节点的数目范围是[0, 50000]
0 <= Node.val <= 50000
题目数据保证输入的树是 完全二叉树

递归遍历：

一般做法

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

利用完全二叉树的特性：
如果完全二叉树为满二叉树时，直接返回二叉树的个数，减少二叉树遍历的次数，此时时间复杂度为O(log²n)，代码如下：

class Solution {
public:
    int countNodes(TreeNode* root) {
        if (!root) return 0;
        auto l = root->left, r = root->right;
        int x = 1, y = 1;
        while (l) l = l->left, x ++ ;
        while (r) r = r->right, y ++ ;
        if (x == y) return (1 << x) - 1;
        return countNodes(root->left) + 1 + countNodes(root->right);
    }
};

层序遍历：

class Solution {
public:
    int countNodes(TreeNode* root) {
        int res = 0;
        queue<TreeNode*> q;
        if (root) q.push(root);
        while (q.size()) {
            auto t = q.front();
            q.pop();
            res++;
            if (t->left) q.push(t->left);
            if (t->right) q.push(t->right);
        }
        return res;
    }
};

110. 平衡二叉树

给定一个二叉树，判断它是否是高度平衡的二叉树。
本题中，一棵高度平衡二叉树定义为：
一个二叉树每个节点的左右两个子树的高度差的绝对值不超过 1 。

示例 1：

在这里插入图片描述

输入：root = [3,9,20,null,null,15,7]
输出：true

示例 2：

在这里插入图片描述

输入：root = [1,2,2,3,3,null,null,4,4]
输出：false

示例 3：

输入：root = []
输出：true

提示：

树中的节点数在范围 [0, 5000] 内
-10⁴ <= Node.val <= 10⁴

递归遍历：

class Solution {
public:
    bool res = true;

    bool isBalanced(TreeNode* root) {
        dfs(root);
        return res;
    }

    int dfs(TreeNode* root) {
        if (!root) return 0;
        int lh = dfs(root->left), rh = dfs(root->right);
        if (abs(lh - rh) > 1) res = false;
        return max(lh, rh) + 1;
    }
};

257. 二叉树的所有路径

给你一个二叉树的根节点 root ，按 任意顺序 ，返回所有从根节点到叶子节点的路径。
叶子节点 是指没有子节点的节点。

示例 1：

在这里插入图片描述

输入：root = [1,2,3,null,5]
输出：["1->2->5","1->3"]

示例 2：

输入：root = [1]
输出：["1"]

提示：

树中节点的数目在范围 [1, 100] 内
-100 <= Node.val <= 100

深搜算法：

class Solution {
public:
    vector<string> res;
    vector<int> path;

    vector<string> binaryTreePaths(TreeNode* root) {
        if(root) dfs(root);
        return res;
    }

    void dfs(TreeNode* root) {
        path.push_back(root->val);
        if (!root->left && !root->right) {
            string line = to_string(path[0]);
            for (int i = 1; i < path.size(); i++) 
                line += "->" + to_string(path[i]);
            res.push_back(line);
        }
        else {
            if (root->left) dfs(root->left);
            if (root->right) dfs(root->right);
        }
        path.pop_back();
    }
};

404. 左叶子之和

给定二叉树的根节点 root ，返回所有左叶子之和。

示例 1：

在这里插入图片描述

输入: root = [3,9,20,null,null,15,7]
输出: 24
解释: 在这个二叉树中，有两个左叶子，分别是 9 和 15，所以返回 24

示例 2：

输入: root = [1]
输出: 0

提示：

节点数在 [1, 1000] 范围内
-1000 <= Node.val <= 1000

递归遍历：

class Solution {
public:
    int res = 0;
    int sumOfLeftLeaves(TreeNode* root) {
        dfs(root);
        return res;
    }

    void dfs(TreeNode* root) {
        if (!root) return;
        if (root->left) {
            if (!root->left->left && !root->left->right) 
                res += root->left->val;
        }
        dfs(root->left);
        dfs(root->right);
    }
};

513. 找树左下角的值

给定一个二叉树的根节点 root，请找出该二叉树的 最底层最左边 节点的值。
假设二叉树中至少有一个节点。

示例 1：

请添加图片描述

输入: root = [2,1,3]
输出: 1

示例 2：

在这里插入图片描述

输入: [1,2,3,4,null,5,6,null,null,7]
输出: 7

提示：

二叉树的节点个数的范围是 [1,10⁴]
-2³¹ <= Node.val <= 2³¹ - 1

解题思路：

因为要找左下角的值，因此先搜索二叉树的左子树，再搜索它的右子树，这样的搜索顺序就会保证每一层最左边的元素相对同一层其他元素来说能够被最先搜索到；
maxd记录树的深度，搜索过程中，d表示当前节点的深度，若d > maxd，此时更新maxd和res。

递归遍历：

class Solution {
public:
    int res, maxd = 0;
    int findBottomLeftValue(TreeNode* root) {
        dfs(root, 1);
        return res;
    }
    void dfs(TreeNode* root, int d) {
        if (!root) return;
        if (d > maxd) {
            maxd = d;
            res = root->val;
        }
        dfs(root->left, d + 1);
        dfs(root->right, d + 1);
    }
};

112. 路径总和

给你二叉树的根节点 root 和一个表示目标和的整数 targetSum 。判断该树中是否存在 根节点到叶子节点 的路径，这条路径上所有节点值相加等于目标和 targetSum 。如果存在，返回 true ；否则，返回 false 。
叶子节点 是指没有子节点的节点。

示例 1：

在这里插入图片描述

输入：root = [5,4,8,11,null,13,4,7,2,null,null,null,1], targetSum = 22
输出：true
解释：等于目标和的根节点到叶节点路径如上图所示。

示例 2：

在这里插入图片描述

输入：root = [1,2,3], targetSum = 5
输出：false
解释：树中存在两条根节点到叶子节点的路径：
(1 --> 2): 和为 3
(1 --> 3): 和为 4
不存在 sum = 5 的根节点到叶子节点的路径。

示例 3：

输入：root = [], targetSum = 0
输出：false
解释：由于树是空的，所以不存在根节点到叶子节点的路径。

提示：

树中节点的数目在范围 [0, 5000] 内
-1000 <= Node.val <= 1000
-1000 <= targetSum <= 1000

递归遍历：

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

105. 从前序与中序遍历序列构造二叉树

给定两个整数数组 preorder 和 inorder ，其中 preorder 是二叉树的先序遍历， inorder 是同一棵树的中序遍历，请构造二叉树并返回其根节点。

示例 1:

在这里插入图片描述

输入: preorder = [3,9,20,15,7], inorder = [9,3,15,20,7]
输出: [3,9,20,null,null,15,7]

示例 2:

输入: preorder = [-1], inorder = [-1]
输出: [-1]

提示:

1 <= preorder.length <= 3000
inorder.length == preorder.length
-3000 <= preorder[i], inorder[i] <= 3000
preorder 和 inorder 均 无重复 元素
inorder 均出现在 preorder
preorder 保证为二叉树的前序遍历序列
inorder 保证为二叉树的中序遍历序列

解题思路：

(递归) O(n)

递归建立整棵二叉树：先递归创建左右子树，然后创建根节点，并让指针指向两棵子树。

具体步骤如下：

先利用前序遍历找根节点：前序遍历的第一个数，就是根节点的值；
在中序遍历中找到根节点的位置 k，则 k 左边是左子树的中序遍历，右边是右子树的中序遍历；
假设左子树的中序遍历的长度是 l，则在前序遍历中，根节点后面的 l 个数，是左子树的前序遍历，剩下的数是右子树的前序遍历；
有了左右子树的前序遍历和中序遍历，我们可以先递归创建出左右子树，然后再创建根节点；

时间复杂度分析：我们在初始化时，用哈希表unordered_map<int,int>记录每个值在中序遍历中的位置，这样我们在递归到每个节点时，在中序遍历中查找根节点位置的操作，只需要 O(1) 的时间。此时，创建每个节点需要的时间是 O(1)，所以总时间复杂度是 O(n)。

C++代码：

class Solution {
public:

    unordered_map<int, int> pos;

    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
        for (int i = 0; i < inorder.size(); i++) pos[inorder[i]] = i;
        return dfs(preorder, inorder, 0, preorder.size() - 1, 0, inorder.size() - 1);
    }

    TreeNode* dfs(vector<int>& preorder, vector<int>& inorder, int pl, int pr, int il, int ir) {
        if (pl > pr) return nullptr;
        auto root = new TreeNode(preorder[pl]);
        int k = pos[preorder[pl]];
        root->left = dfs(preorder, inorder, pl + 1, pl + 1 + k - 1  - il, il, k - 1);
        root->right = dfs(preorder, inorder, pl + 1 + k - 1 - il + 1, pr, k + 1, ir);
        return root;
    }
};

654. 最大二叉树

给定一个不重复的整数数组 nums 。 最大二叉树 可以用下面的算法从 nums 递归地构建:

创建一个根节点，其值为 nums 中的最大值。
递归地在最大值左边的 子数组前缀上 构建左子树。
递归地在最大值右边的 子数组后缀上 构建右子树。
返回 nums 构建的最大二叉树。

示例 1：

在这里插入图片描述

输入：nums = [3,2,1,6,0,5]
输出：[6,3,5,null,2,0,null,null,1]
解释：递归调用如下所示：
- [3,2,1,6,0,5] 中的最大值是 6 ，左边部分是 [3,2,1] ，右边部分是 [0,5] 。
    - [3,2,1] 中的最大值是 3 ，左边部分是 [] ，右边部分是 [2,1] 。
        - 空数组，无子节点。
        - [2,1] 中的最大值是 2 ，左边部分是 [] ，右边部分是 [1] 。
            - 空数组，无子节点。
            - 只有一个元素，所以子节点是一个值为 1 的节点。
    - [0,5] 中的最大值是 5 ，左边部分是 [0] ，右边部分是 [] 。
        - 只有一个元素，所以子节点是一个值为 0 的节点。
        - 空数组，无子节点。

示例 2：

输入：nums = [3,2,1]
输出：[3,null,2,null,1]

提示：

1 <= nums.length <= 1000
0 <= nums[i] <= 1000
nums 中的所有整数 互不相同

解题思路：

(递归)

递归建立整棵二叉树：先递归创建左右子树，然后创建根节点，并让指针指向两棵子树。

具体步骤如下：

先利用整数数组找根节点：整数数组的最大值maxValue，就是根节点的值，根节点在数组中的下标记为maxIndex；
根节点下标 maxIndex 左边的子数组表示左子树，右边的子数组表示右子树；
有了左右子树的所在子数组，我们可以先递归创建出左右子树，然后再创建根节点；

C++代码：

class Solution {
public:
    TreeNode* constructMaximumBinaryTree(vector<int>& nums) {
        return dfs(nums, 0, nums.size() - 1);
    }

    TreeNode* dfs(vector<int>& nums, int l, int r) {
        if (l > r) return nullptr;
        int maxValue = nums[l], maxIndex = l;
        for (int i = l + 1; i <= r; i++) 
            if (maxValue < nums[i]) maxValue = nums[i], maxIndex = i;
        auto root = new TreeNode(maxValue);
        root->left = dfs(nums, l, maxIndex - 1);
        root->right = dfs(nums, maxIndex + 1, r);
        return root;
    }
};

617. 合并二叉树

给你两棵二叉树： root1 和 root2 。

想象一下，当你将其中一棵覆盖到另一棵之上时，两棵树上的一些节点将会重叠（而另一些不会）。你需要将这两棵树合并成一棵新二叉树。合并的规则是：如果两个节点重叠，那么将这两个节点的值相加作为合并后节点的新值；否则，不为 null 的节点将直接作为新二叉树的节点。

返回合并后的二叉树。

注意: 合并过程必须从两个树的根节点开始。

示例 1：

在这里插入图片描述

输入：root1 = [1,3,2,5], root2 = [2,1,3,null,4,null,7]
输出：[3,4,5,5,4,null,7]

示例 2：

输入：root1 = [1], root2 = [1,2]
输出：[2,2]

提示：

两棵树中的节点数目在范围 [0, 2000] 内
-10⁴ <= Node.val <= 10⁴

C++代码：

class Solution {
public:
    TreeNode* mergeTrees(TreeNode* root1, TreeNode* root2) {
        if (!root1 && !root2) return nullptr;
        if (!root1) return root2;
        if (!root2) return root1;
        auto root = new TreeNode(root1->val + root2->val);
        root->left = mergeTrees(root1->left, root2->left);
        root->right = mergeTrees(root1->right, root2->right);
        return root;
    }
};

700. 二叉搜索树中的搜索

给定二叉搜索树（BST）的根节点 root 和一个整数值 val。

你需要在 BST 中找到节点值等于 val 的节点。返回以该节点为根的子树。如果节点不存在，则返回 null 。

示例 1:

在这里插入图片描述

输入：root = [4,2,7,1,3], val = 2
输出：[2,1,3]

示例 2:

在这里插入图片描述

输入：root = [4,2,7,1,3], val = 5
输出：[]

提示：

数中节点数在 [1, 5000] 范围内
1 <= Node.val <= 10⁷
root 是二叉搜索树
1 <= val <= 10⁷

C++代码：

class Solution {
public:
    TreeNode* searchBST(TreeNode* root, int val) {
        if (!root) return nullptr;
        if (val == root->val) return root;
        if (val > root->val) return searchBST(root->right, val); //递归遍历右子树
        else return searchBST(root->left, val); //递归遍历左子树
    }
};

98. 验证二叉搜索树

给你一个二叉树的根节点 root ，判断其是否是一个有效的二叉搜索树。

有效二叉搜索树定义如下：

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

示例 1：

输入：root = [2,1,3]
输出：true

示例 2：

输入：root = [5,1,4,null,null,3,6]
输出：false
解释：根节点的值是 5 ，但是右子节点的值是 4 。

提示：

树中节点数目范围在[1, 10⁴] 内
-2³¹ <= Node.val <= 2³¹ - 1

class Solution {
public:
    bool isValidBST(TreeNode* root) {
        return bfs(root, LONG_MIN, LONG_MAX);
    }
    bool bfs(TreeNode* root, long long min, long long max) {
        if (!root) return true;
        if (root->val <= min || root->val >= max) return false;
        //递归遍历左右子树，并且左右儿子的取值范围也会不断更新，缩小取值范围
        return bfs(root->left, min, root->val) && bfs(root->right, root->val, max);
    }
};

// 方法二： 运用中序遍历进行验证
class Solution {
public:
    vector<int> res;
    bool isValidBST(TreeNode* root) {
        dfs(root);
        for (int i = 1; i < res.size(); i++) 
            if (res[i] <= res[i - 1]) return false;
        return true;
    }
    void dfs(TreeNode* root) {
        if (!root) return ;
        dfs(root->left);
        res.push_back(root->val);
        dfs(root->right);
    }
};

530. 二叉搜索树的最小绝对差

给你一个二叉搜索树的根节点 root ，返回 树中任意两不同节点值之间的最小差值 。
差值是一个正数，其数值等于两值之差的绝对值。

示例 1：

在这里插入图片描述

输入：root = [4,2,6,1,3]
输出：1

示例 2：

在这里插入图片描述

输入：root = [1,0,48,null,null,12,49]
输出：1

提示：

树中节点的数目范围是 [2, 10⁴]
0 <= Node.val <= 10⁵

解题思路：
由于二叉搜索树的中序遍历为单调递增序列，则最小绝对差一定是中序遍历序列中某相邻两个值之差。

C++代码：

public:
    int res = INT_MAX, last; //last记录前一个数
    bool is_first = true; //标记中序遍历序列的第一个数
    int getMinimumDifference(TreeNode* root) {
        dfs(root);
        return res;
    }
    //二叉搜索树运用中序遍历，遍历的结果单调递增
    void dfs(TreeNode* root) {
        if (!root) return;
        dfs(root->left);
        if (is_first) is_first = false; //特殊处理第一个数
        else res = min(res, root->val - last);
        last = root->val;
        dfs(root->right);
    }
};

501. 二叉搜索树中的众数

给你一个含重复值的二叉搜索树（BST）的根节点 root ，找出并返回 BST 中的所有众数（即，出现频率最高的元素）。
如果树中有不止一个众数，可以按 任意顺序 返回。

假定 BST 满足如下定义：

结点左子树中所含节点的值 小于等于 当前节点的值
结点右子树中所含节点的值 大于等于 当前节点的值
左子树和右子树都是二叉搜索树

示例 1：

在这里插入图片描述

输入：root = [1,null,2,2]
输出：[2]

示例 2：

输入：root = [0]
输出：[0]

提示：

树中节点的数目在范围 [1, 10⁴] 内
-10⁵ <= Node.val <= 10⁵

解题思路：

二叉搜索树的中序遍历产生的数组为非严格单调递增的序列，那么重复值一定相邻，由此可通过双指针或者哈希算法得到每个不同数值的出现次数，由此找出BST的众数。

C++代码：

class Solution {
public:
    vector<int> s;

    vector<int> findMode(TreeNode* root) {
        dfs(root);
        vector<int> res;
        unordered_map<int, int> count;
        for (auto c: s) count[c]++;
        int x = s[0];
        for (int i = 0; i < s.size(); i++) {
            if (count[s[i]] > count[x]) x = s[i];
        }
        for (int i = 0; i < s.size(); i++) {
            if (count[s[i]] == count[x]) res.push_back(s[i]);
        }
        res.erase(unique(res.begin(), res.end()), res.end());
        return res;
    }

    void dfs(TreeNode* root) {
        if (!root) return;
        dfs(root->left);
        s.push_back(root->val);
        dfs(root->right);
    }
};

236. 二叉树的最近公共祖先

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

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

示例 1：

在这里插入图片描述

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

示例 2：

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

示例 3：

输入：root = [1,2], p = 1, q = 2
输出：1

提示：

树中节点数目在范围 [2, 10⁵] 内。
-10⁹ <= Node.val <= 10⁹
所有 Node.val 互不相同。
p != q
p 和 q 均存在于给定的二叉树中。

C++代码：

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

235. 二叉搜索树的最近公共祖先

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

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

例如，给定如下二叉搜索树: root = [6,2,8,0,4,7,9,null,null,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 为不同节点且均存在于给定的二叉搜索树中。

C++代码：

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

701. 二叉搜索树中的插入操作

给定二叉搜索树（BST）的根节点 root 和要插入树中的值 value ，将值插入二叉搜索树。返回插入后二叉搜索树的根节点。输入数据保证新值和原始二叉搜索树中的任意节点值都不同。

注意，可能存在多种有效的插入方式，只要树在插入后仍保持为二叉搜索树即可。你可以返回 任意有效的结果 。

示例 1：

在这里插入图片描述

输入：root = [4,2,7,1,3], val = 5
输出：[4,2,7,1,3,5]
解释：另一个满足题目要求可以通过的树是：

在这里插入图片描述

示例 2：

输入：root = [40,20,60,10,30,50,70], val = 25
输出：[40,20,60,10,30,50,70,null,null,25]

示例 3：

输入：root = [4,2,7,1,3,null,null,null,null,null,null], val = 5
输出：[4,2,7,1,3,5]

提示：

树中的节点数将在 [0, 10⁴]的范围内。
-10⁸ <= Node.val <= 10⁸
所有值 Node.val 是独一无二的。
-10⁸ <= val <= 10⁸
保证 val 在原始BST中不存在。

C++代码：

class Solution {
public:
    TreeNode* insertIntoBST(TreeNode* root, int val) {
        TreeNode* node = new TreeNode(val);
        if (!root) return node;
        if (root->val < val) {
            if (!root->right) root->right = node;
            else insertIntoBST(root->right, val);
        }
        if (root->val > val) {
            if (!root->left) root->left = node;
            else insertIntoBST(root->left, val);
        }
        return root;
    }
};

450. 删除二叉搜索树中的节点

给定一个二叉搜索树的根节点 root 和一个值 key，删除二叉搜索树中的 key 对应的节点，并保证二叉搜索树的性质不变。返回二叉搜索树（有可能被更新）的根节点的引用。

一般来说，删除节点可分为两个步骤：

首先找到需要删除的节点；
如果找到了，删除它。

示例 1:

在这里插入图片描述

输入：root = [5,3,6,2,4,null,7], key = 3
输出：[5,4,6,2,null,null,7]
解释：给定需要删除的节点值是 3，所以我们首先找到 3 这个节点，然后删除它。
一个正确的答案是 [5,4,6,2,null,null,7], 如下图所示。

在这里插入图片描述

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

示例 2:

输入: root = [5,3,6,2,4,null,7], key = 0
输出: [5,3,6,2,4,null,7]
解释: 二叉树不包含值为 0 的节点

示例 3:

输入: root = [], key = 0
输出: []

提示:

节点数的范围 [0, 10⁴]
-10⁵ <= Node.val <= 10⁵
节点值唯一
root 是合法的二叉搜索树
-10⁵ <= key <= 10⁵

进阶： 要求算法时间复杂度为 O(h)，h 为树的高度。

解题思路：

如果删除的节点为根节点，则需要判断是否存在左右子树：
- 若只有左子树存在，则将根的左儿子作为新的根节点；
- 若只有右子树存在，则将根的右儿子作为新的根节点；
- 若左右子树均存在，则将左子树中的最大值（左子树最右边的叶子节点）作为新的根节点的值，并删除左子树最右边的叶子节点；
  或者将右子树中的最小值（右子树最左边的叶子节点）作为新的根节点的值，并删除右子树最左边的叶子节点；
如果删除节点的值小于根节点的值，递归遍历左子树；
如果删除节点的值大于根节点的值，递归遍历右子树；

C++代码：

class Solution {
public:
    TreeNode* deleteNode(TreeNode* root, int key) {
        del(root, key);
        return root;
    }

    void del(TreeNode* &root, int key) {
        if (!root) return;
        if (key == root->val) {
            if (!root->left && !root->right) root = nullptr;
            else if (!root->left) root = root->right;
            else if (!root->right) root = root->left;
            else {
                auto p = root->left;
                while (p->right) p = p->right;
                root->val = p->val;
                del(root->left, p->val);
            }
        }
        else if (key < root->val) del(root->left, key);
        else del(root->right, key);
    }
};

669. 修剪二叉搜索树

给你二叉搜索树的根节点 root ，同时给定最小边界low 和最大边界 high。通过修剪二叉搜索树，使得所有节点的值在[low, high]中。修剪树 不应该 改变保留在树中的元素的相对结构 (即，如果没有被移除，原有的父代子代关系都应当保留)。可以证明，存在 **唯一的答案 **。

所以结果应当返回修剪好的二叉搜索树的新的根节点。注意，根节点可能会根据给定的边界发生改变。

示例 1：

在这里插入图片描述

输入：root = [1,0,2], low = 1, high = 2
输出：[1,null,2]

示例 2：

在这里插入图片描述

输入：root = [3,0,4,null,2,null,null,1], low = 1, high = 3
输出：[3,2,null,1]

提示：

树中节点数在范围 [1, 10⁴] 内
0 <= Node.val <= 10⁴
树中每个节点的值都是唯一的
题目数据保证输入是一棵有效的二叉搜索树
0 <= low <= high <= 10⁴

解题思路：

当根节点的值小于low时，则说明根节点及其左子树的所有数都小于low，因此可将右儿子作为新的根节点继续修剪二叉搜索树；
当根节点的值大于high时，则说明根节点及其右子树的所有数都大于high，因此可将左儿子作为新的根节点继续修剪二叉搜索树；
当根节点的值位于[low, high]中时，递归遍历左右子树，将修剪后的左右子树根节点作为新的左右儿子，最终返回根节点。

C++代码：

class Solution {
public:
    TreeNode* trimBST(TreeNode* root, int low, int high) {
        if (!root) return nullptr;
        if (root->val < low) return trimBST(root->right, low, high);
        if (root->val > high) return trimBST(root->left, low, high);
        root->left = trimBST(root->left, low, high);
        root->right = trimBST(root->right, low, high);
        return root;
    }
};

108. 将有序数组转换为二叉搜索树

给你一个整数数组 nums ，其中元素已经按升序排列，请你将其转换为一棵 高度平衡 二叉搜索树。

高度平衡 二叉树是一棵满足 **每个节点的左右两个子树的高度差的绝对值不超过 1 ** 的二叉树。

示例 1：

输入：nums = [-10,-3,0,5,9]
输出：[0,-3,9,-10,null,5]
解释：[0,-10,5,null,-3,null,9] 也将被视为正确答案：

示例 2：

输入：nums = [1,3]
输出：[3,1]
解释：[1,null,3] 和 [3,1] 都是高度平衡二叉搜索树。

提示：

1 <= nums.length <= 10⁴
-10⁴ <= nums[i] <= 10⁴
nums 按 严格递增 顺序排列

解题思路：

由于给出的整数数组是单调递增的序列，因此二叉搜索树的中序遍历刚好就是该数组的排列顺序；
题目要求此二叉搜索树高度平衡，也就是说左右子树的节点数目相当，可将数组的中值数作为根节点的值；
运用递归遍历的方法，对左右子树继续遍历排序。

class Solution {
public:
    TreeNode* sortedArrayToBST(vector<int>& nums) {
        return dfs(nums, 0, nums.size() - 1);
    }

    TreeNode* dfs(vector<int>& nums, int l, int r) {
        if (l > r) return nullptr;
        int mid = (l + r) / 2;
        auto root = new TreeNode(nums[mid]);
        root->left = dfs(nums, l, mid - 1);
        root->right = dfs(nums, mid + 1, r);
        return root;
    } 
};

538. 把二叉搜索树转换为累加树

给出二叉搜索树的根节点，该树的节点值各不相同，请你将其转换为 累加树 （Greater Sum Tree），使每个节点 node 的新值等于原树中大于或等于 node.val 的值之和。

提醒一下，二叉搜索树满足下列约束条件：

节点的左子树仅包含键小于节点键的节点。
节点的右子树仅包含键大于节点键的节点。
左右子树也必须是二叉搜索树。

**注意：**本题和 1038: https://leetcode-cn.com/problems/binary-search-tree-to-greater-sum-tree/ 相同

示例 1：

在这里插入图片描述

输入：[4,1,6,0,2,5,7,null,null,null,3,null,null,null,8]
输出：[30,36,21,36,35,26,15,null,null,null,33,null,null,null,8]

示例 2：

输入：root = [0,null,1]
输出：[1,null,1]

示例 3：

输入：root = [1,0,2]
输出：[3,3,2]

示例 4：

输入：root = [3,2,4,1]
输出：[7,9,4,10]

提示：

树中的节点数介于 0 和 10⁴ 之间。
每个节点的值介于 -10⁴ 和 10⁴ 之间。
树中的所有值 互不相同 。
给定的树为二叉搜索树。

解题思路：

由于要求每个节点node的新值等于原树中大于或等于node.val的值之和，也就是说每个节点的值等于它的右子树节点和本节点的值之和；
二叉搜索树按 右中左 的顺序进行遍历，可得到一个单调递减的序列；
在遍历二叉搜索树的过程中，对当前节点的值进行处理，将当前节点的值加上前面已遍历的值之和作为当前节点新的值；
遍历完成后，将根节点作为结果返回。

C++代码：

class Solution {
public:
    int sum = 0;

    TreeNode* convertBST(TreeNode* root) {
        dfs(root);
        return root;
    }

    void dfs(TreeNode* root) {
        if (!root) return;
        dfs(root->right);
        sum += root->val;
        root->val = sum;
        dfs(root->left);
    }
};

程序员小浩

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
打赏
0
评论
代码随想录（六）：二叉树

力扣144、94、145、102、226、101、104、559、111、222、110、257、404、513、112、105、654、617、700、98、530、501、236、235、701、450、669、108、538
复制链接

扫一扫