算法Day17|.二叉树专题六 236. 二叉树的最近公共祖先，235. 二叉搜索树的最近公共祖先，701.二叉搜索树中的插入操作，450.删除二叉搜索树中的节点

Road_slow

已于 2022-11-20 10:50:30 修改

阅读量116

点赞数

分类专栏：算法文章标签：算法数据结构 java leetcode

于 2022-11-12 10:37:42 首次发布

原文链接：https://programmercarl.com/

版权

算法专栏收录该内容

38 篇文章 0 订阅

订阅专栏

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

1.题目描述

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

2.解题思路

首先最容易想到的一个情况：如果找到一个节点，发现左子树出现结点p，右子树出现节点q，或者左子树出现结点q，右子树出现节点p，那么该节点就是节点p和q的最近公共祖先。即情况一：

情况二：

其实情况一和情况二代码实现过程都是一样的，也可以说，实现情况一的逻辑，顺便包含了情况二。

因为遇到 q 或者 p 就返回，这样也包含了 q 或者 p 本身就是公共祖先的情况。

3.代码实现

1.确定递归函数的参数和返回值：

递归函数定义：参数-传入一个根节点，两个目标节点。

返回：两个目标节点的最近公共祖先。

   public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {}

2.确定终止条件：

遇到空的话，因为树都是空了，所以返回空。
如果 root == q，或者 root == p，说明找到 q 或p ，则将其返回。

        //递归终止条件
        if (root == null || root.val == p.val || root.val == q.val) {
            return root;
        }

3.确定单层递归的逻辑：

注意：一定要知道递归函数是干嘛的，就是找p和q的最小公共祖先。下面的逻辑把递归函数当成黑盒，就默认它能实现我们的逻辑。

1.先用left和right接住左子树和右子树的递归返回值。
2.如果left为空，right不为空，就返回right，说明目标节点是通过right返回的，反之依然。
说明：我的递归函数在右边找到了公共祖先，那右边的结果就是题目要求的呀！反之也一样。
3.如果left为空，right为空，说明树中没有p和q，返回nul。
说明：我的递归函数在左边和右边都找不到公共祖先，那就是返回null了。
4如果left 和 right都不为空，说明此时root就是最近公共节点。
说明：我的递归函数在左边和右边都找到了公共祖先，那你想为什么左边和右边都能找到呢？看递归的终止条件，说明一边有p，一边有q呀，那root自然就是最小公共祖先了。

        TreeNode left = lowestCommonAncestor(root.left, p, q);
        TreeNode right = lowestCommonAncestor(root.right, p, q);
        if (left != null && right == null) {
            return left; // 若找到一个节点
        } else if (left == null && right != null) {
            return right; // 若找到一个节点
        } else if (left == null || right == null) {
            return null;// 若未找到节点 p 或 q
        } else {
            return root;// 若找到两个节点
        }

完整代码如下：

class Solution {
   //236. 二叉树的最近公共祖先
    //递归函数定义：参数-传入一个根节点，两个目标节点
    //返回：两个目标节点的最近公共祖先
    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
        //递归终止条件
        if (root == null || root.val == p.val || root.val == q.val) {
            return root;
        }
        TreeNode left = lowestCommonAncestor(root.left, p, q);
        TreeNode right = lowestCommonAncestor(root.right, p, q);
        if (left != null && right == null) {
            return left; // 若找到一个节点
        } else if (left == null && right != null) {
            return right; // 若找到一个节点
        } else if (left == null || right == null) {
            return null;// 若未找到节点 p 或 q
        } else {
            return root;// 若找到两个节点
        }
    }
}

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

1.题目描述

给定一个二叉搜索树, 找到该树中两个指定节点的最近公共祖先。
百度百科中最近公共祖先的定义为：“对于有根树 T 的两个结点 p、q，最近公共祖先表示为一个结点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大（一个节点也可以是它自己的祖先）。”
例如，给定如下二叉搜索树: root = [6,2,8,0,4,7,9,null,null,3,5]

2.解题思路

在有序树里，如果判断一个节点的左子树里有p，右子树里有q呢？
因为是有序树，所有如果中间节点是 q 和 p 的公共祖先，那么中节点的数组一定是在 [p, q]区间的。即中节点 > p && 中节点 < q 或者中节点 > q && 中节点 < p。
那么只要从上到下去遍历，遇到 cur节点是数值在[p, q]区间中则一定可以说明该节点cur就是q 和 p的公共祖先。那问题来了，一定是最近公共祖先吗？
如图，我们从根节点搜索，第一次遇到 cur节点是数值在[p, q]区间中，即节点5，此时可以说明 p 和 q 一定分别存在于节点 5的左子树，和右子树中。

此时节点5是不是最近公共祖先？如果从节点5继续向左遍历，那么将错过成为q的祖先，如果从节点5继续向右遍历则错过成为p的祖先。
所以当我们从上向下去递归遍历，第一次遇到 cur节点是数值在[p, q]区间中，那么cur就是 p和q的最近公共祖先。
理解这一点，本题就很好解了。
而递归遍历顺序，本题就不涉及到前中后序了（这里没有中节点的处理逻辑，遍历顺序无所谓了）。
如图所示：p为节点3，q为节点5

可以看出直接按照指定的方向，就可以找到节点4，为最近公共祖先，而且不需要遍历整棵树，找到结果直接返回！

3.代码实现

class Solution {
    //235. 二叉搜索树的最近公共祖先
    //递归函数定义：参数-传入一个根节点，两个目标节点
    //返回：两个目标节点的最近公共祖先
    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
        //递归终止条件
        if (root == null || root.val == p.val || root.val == q.val) {
            return root;
        }
        //搜索树是有方向了，可以根据p,q和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.二叉搜索树中的插入操作

1.题目描述

给定二叉搜索树（BST）的根节点 root 和要插入树中的值 value ，将值插入二叉搜索树。返回插入后二叉搜索树的根节点。输入数据保证，新值和原始二叉搜索树中的任意节点值都不同。
注意，可能存在多种有效的插入方式，只要树在插入后仍保持为二叉搜索树即可。你可以返回任意有效的结果。

2.解题思路

如下演示视频中可以看出：只要按照二叉搜索树的规则去遍历，遇到空节点就插入节点就可以了。

例如插入元素10 ，需要找到末尾节点插入便可，一样的道理来插入元素15，插入元素0，插入元素6，需要调整二叉树的结构么？并不需要。。

只要遍历二叉搜索树，找到空节点插入元素就可以了，那么这道题其实就简单了。

接下来就是遍历二叉搜索树的过程了。

3.代码实现

class Solution {
    //701.二叉搜索树中的插入操作
    public TreeNode insertIntoBST(TreeNode root, int val) {
        //递归终止条件
        if (root == null) {
            return new TreeNode(val);
        }
        //搜索树是有方向了，可以根据插入元素的数值，决定递归方向。
        if (root.val > val) {
            root.left = insertIntoBST(root.left, val);
        }
        if (root.val < val) {
            root.right = insertIntoBST(root.right, val);
        }
        return root;
    }
}

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

1.题目描述

给定一个二叉搜索树的根节点 root 和一个值 key，删除二叉搜索树中的 key 对应的节点，并保证二叉搜索树的性质不变。返回二叉搜索树（有可能被更新）的根节点的引用。
一般来说，删除节点可分为两个步骤：
首先找到需要删除的节点；
如果找到了，删除它。

2.解题思路

搜索树的节点删除要比节点增加复杂的多，有很多情况需要考虑，做好心里准备。

3.代码实现

1.确定递归函数的参数和返回值：

递归函数定义：参数-传入一个根节点，要删除的的节点值。

返回：删除目标节点值后的二叉搜索树的根节点。

    //450.删除二叉搜索树中的节点
    public TreeNode deleteNode(TreeNode root, int key) {}

2.确定终止条件：

遇到空返回，其实这也说明没找到删除的节点，遍历到空节点直接返回了。

      // 第一种情况：没找到删除的节点，遍历到空节点直接返回了
        if (root == null) {
            return root;
        }

3.确定单层递归的逻辑：

这里就把二叉搜索树中删除节点遇到的情况都搞清楚。

有以下五种情况：

第一种情况：没找到删除的节点，遍历到空节点直接返回了
找到删除的节点
第二种情况：左右孩子都为空（叶子节点），直接删除节点，返回NULL为根节点
第三种情况：删除节点的左孩子为空，右孩子不为空，删除节点，右孩子补位，返回右孩子为根节点
第四种情况：删除节点的右孩子为空，左孩子不为空，删除节点，左孩子补位，返回左孩子为根节点
第五种情况：左右孩子节点都不为空，则将删除节点的左子树头结点（左孩子）放到删除节点的右子树的最左面节点的左孩子上，返回删除节点右孩子为新的根节点。

第五种情况有点难以理解，看下面动画：

动画中棵二叉搜索树中，删除元素7，那么删除节点（元素7）的左孩子就是5，删除节点（元素7）的右子树的最左面节点是元素8。
将删除节点（元素7）的左孩子放到删除节点（元素7）的右子树的最左面节点（元素8）的左孩子上，就是把5为根节点的子树移到了8的左孩子的位置。
要删除的节点（元素7）的右孩子（元素9）为新的根节点。.
这样就完成删除元素7的逻辑，最好动手画一个图，尝试删除一个节点试试。

完整代码如下：

class Solution {
  //450.删除二叉搜索树中的节点
    public TreeNode deleteNode(TreeNode root, int key) {
        // 第一种情况：没找到删除的节点，遍历到空节点直接返回了
        if (root == null) {
            return root;
        }
        if (root.val == key) {
            // 第二种情况：左右孩子都为空（叶子节点），直接删除节点，
           // 返回NULL为根节点
            if (root.left == null && root.right == null) {
                return null;
                // 第三种情况：其左孩子为空，右孩子不为空，删除节点，
                //右孩子补位 ，返回右孩子为根节点
            } else if (root.left == null && root.right != null) {
                return root.right;
                // 第四种情况：其右孩子为空，左孩子不为空，删除节点，
               //左孩子补位，返回左孩子为根节点
            } else if (root.left != null && root.right == null) {
                return root.left;
            } else {
                // 第五种情况：左右孩子节点都不为空，
           //则将删除节点的左子树放到删除节点的右子树的最左面节点的左孩子的位置
                // 并返回删除节点右孩子为新的根节点。
                TreeNode cur = root.right;
                // 找右子树最左面的节点
                while (cur.left != null) {
                    cur = cur.left;
                }
                // 把要删除的节点（root）左子树放在cur的左孩子的位置
                cur.left = root.left;
                // 返回旧root的右孩子作为新root
                return root.right;
            }
        }
        //key比root的值小，去root的左子树寻找
        if (root.val > key) {
            root.left = deleteNode(root.left, key);
        }
        //key比root的值大，去root的右子树寻找
        if (root.val < key) {
            root.right = deleteNode(root.right, key);
        }
        return root;
    }
}

Road_slow

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
算法Day17|.二叉树专题六 236. 二叉树的最近公共祖先，235. 二叉搜索树的最近公共祖先，701.二叉搜索树中的插入操作，450.删除二叉搜索树中的节点

算法Day17|.二叉树专题六 236. 二叉树的最近公共祖先，235. 二叉搜索树的最近公共祖先，701.二叉搜索树中的插入操作，450.删除二叉搜索树中的节点
复制链接

扫一扫