代码随想录算法训练营day22

最新推荐文章于 2024-10-27 18:45:12 发布

weixin_44806531

最新推荐文章于 2024-10-27 18:45:12 发布

阅读量49

点赞数

文章标签：算法

本文链接：https://blog.csdn.net/weixin_44806531/article/details/131604424

版权

文章目录

Day22

Day22

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

题目

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

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

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-JKIILQCH-1688734689059)(https://code-thinking-1253855093.file.myqcloud.com/pics/20201018172243602.png “235. 二叉搜索树的最近公共祖先”)]

示例 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 为不同节点且均存在于给定的二叉搜索树中。

思路

因为是有序树，所有如果中间节点是 q 和 p 的公共祖先，那么中节点的数组一定是在 [p, q]区间的。即中节点 > p && 中节点 < q 或者中节点 > q && 中节点 < p。

那么只要从上到下去遍历，遇到 cur节点是数值在[p, q]区间中则一定可以说明该节点cur就是q 和 p的公共祖先。那问题来了，一定是最近公共祖先吗？

为什么从上往下遍历第一个节点一定是公共祖先？

代码随想录 (programmercarl.com)

代码

class Solution {
    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
        return traversal(root, p, q);
    }

    public TreeNode traversal(TreeNode root, TreeNode p, TreeNode q){
        if(root == null) return root;

        if(root.val > p.val && root.val > q.val){ // 左 当 root 大于 p和q时，应该去左找
            TreeNode leftNode = traversal(root.left, p, q);
            if (leftNode != null){
                return leftNode;
            }
        }

        if(root.val < p.val && root.val < q.val){ // 右
            TreeNode rightNode = traversal(root.right, p, q);
            if (rightNode != null){
                return rightNode;
            }
        }
        return root;
    }
}

二叉搜索树中的插入操作

701. 二叉搜索树中的插入操作 - 力扣（LeetCode）

题目

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

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-JNrHUCoN-1688734689060)(https://code-thinking-1253855093.file.myqcloud.com/pics/20201019173259554.png “701.二叉搜索树中的插入操作”)]

提示：

给定的树上的节点数介于 0 和 10^4 之间
每个节点都有一个唯一整数值，取值范围从 0 到 10^8
-10^8 <= val <= 10^8
新值和原始二叉搜索树中的任意节点值都不同

思路

可以不考虑题目中提示所说的改变树的结构的插入方式。

只要按照二叉搜索树的规则去遍历，遇到空节点就插入节点就可以了。

代码

递归：无返回值

class Solution {
    TreeNode pre = null;
    public TreeNode insertIntoBST(TreeNode root, int val) {
        if(root == null) {
            TreeNode node = new TreeNode(val);
            return node;
        }
        traversal(root, val);
        return root;
    }

    public TreeNode traversal(TreeNode root, int val){
        if(root == null){
            TreeNode node = new TreeNode(val);
            if(pre.val > val) pre.left = node;
            else pre.right = node;
            return null;
        }
        pre = root;
        if(root.val > val) traversal(root.left, val);
        if(root.val < val) traversal(root.right, val);
        return root;
    }
}

# 递归，有返回值
class Solution {
    public TreeNode insertIntoBST(TreeNode root, int val) {
        if(root == null) {
            TreeNode node = new TreeNode(val);
            return node;
        }
        if(root.val > val) root.left = insertIntoBST(root.left, val);
        if(root.val < val) root.right = insertIntoBST(root.right, val);
        return root;
    }
}

删除二叉搜索树中的节点

450. 删除二叉搜索树中的节点 - 力扣（LeetCode）

题目

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

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

首先找到需要删除的节点；如果找到了，删除它。说明：要求算法时间复杂度为 $O(h)$，h 为树的高度。

示例:

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ID9kAM4S-1688734689060)(https://code-thinking-1253855093.file.myqcloud.com/pics/20201020171048265.png “450.删除二叉搜索树中的节点”)]

思路

节点删除要比节点增加复杂的多，有很多情况需要考虑

第一种情况，没找到节点，直接返回
第二种情况，找到节点，节点左右孩子都为空，删除节点，直接返回空
第三种情况，找到节点，节点左孩子为空，右孩子不为空，删除节点，右孩子补位，返回右孩子为根节点
第四种情况，找到节点，节点左孩子不为空，右孩子为空，删除节点，左孩子补位，返回左孩子为根节点
第五种情况，找到节点，节点左右孩子不为空，删除节点，右子树补位，返回右子树的最左孩子为根节点

代码

详细代码

class Solution {
    public TreeNode deleteNode(TreeNode root, int key) {
        // 第一种情况，没找到节点，直接返回
        if (root == null) return root;
        if(root.val == key){
            // 第二种情况，找到节点，节点左右孩子都为空，删除节点，直接返回空
            if(root.left == null && root.right == null) return null;
            // 第三种情况，找到节点，节点左孩子为空，右孩子不为空，删除节点，右孩子补位 ，返回右孩子为根节点
            if(root.left == null && root.right != null){
                return root.right;
            }
            // 第四种情况，找到节点，节点左孩子不为空，右孩子为空，删除节点，左孩子补位 ，返回左孩子为根节点
            if(root.left != null && root.right == null){
                return root.left;
            }
            // 第五种情况，找到节点，节点左右孩子不为空，删除节点，右子树补位 ，返回右子树的最左孩子为根节点
            if(root.left != null && root.right != null){
                TreeNode cur = root.right;
                while(cur.left != null){
                    cur = cur.left;
                }
                cur.left = root.left;
                root = root.right;
                return root;
            }
        }
		// 这里相当于把新的节点返回给上一层，上一层就要用 root->left 或者 root->right接住
        if(root.val > key) root.left = deleteNode(root.left, key);
        if(root.val < key) root.right = deleteNode(root.right, key);
        return root;
    }
}

精简版

class Solution {
  public TreeNode deleteNode(TreeNode root, int key) {
    if (root == null) return root;
    if (root.val == key) {
      if (root.left == null) {
        return root.right;
      } else if (root.right == null) {
        return root.left;
      } else {
        TreeNode cur = root.right;
        while (cur.left != null) {
          cur = cur.left;
        }
        cur.left = root.left;
        root = root.right;
        return root;
      }
    }
    if (root.val > key) root.left = deleteNode(root.left, key);
    if (root.val < key) root.right = deleteNode(root.right, key);
    return root;
  }
}