代码随想录Day17 | Leetcode530 二叉搜索树的最小绝对差、Leetcode501 二叉搜索树中的众数、Leetcode700 二叉的最近公共祖先-CSDN博客

本文链接：https://blog.csdn.net/qq_41502639/article/details/136034700

代码随想录系列

上题

530. 二叉搜索树的最小绝对差 - 力扣（LeetCode）

501. 二叉搜索树中的众数 - 力扣（LeetCode）

236. 二叉树的最近公共祖先 - 力扣（LeetCode）

第一题

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

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

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

思路

搜索树左子树<结点<右子树，差值最小一定会是相邻两个结点之间出现，使用中序遍历

代码

import collections
from math import inf


class TreeNode:
    def __init__(self, val, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right


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

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

    示例 2：
    输入：root = [1,0,48,null,null,12,49]
    输出：1
    """

    def create_tree(self, root):
        if not root:
            return None
        result = TreeNode(root[0])
        queue = [result]
        i, n = 1, len(root)

        while i < n and queue:
            node = queue.pop(0)
            if i < n and root[i] != 'null':
                root_node = TreeNode(root[i])
                queue.append(root_node)
                node.left = root_node
            i += 1

            if i < n and root[i] != 'null':
                root_node = TreeNode(root[i])
                queue.append(root_node)
                node.right = root_node
            i += 1

        return result

    def getMinimumDifference1(self, root) -> int:
        if not root:
            return
        stack = []
        result = inf
        pre = None
        while root or stack:
            if root:
                stack.append(root)
                root = root.left
            else:
                node = stack.pop()
                if pre:
                    result = min(abs(node.val-pre.val), result)
                pre = node
                root = node.right
        return result

    def getMinimumDifference(self, root) -> int:
        if not root:
            return
        re = []
        result = inf
        self.inorder(root, re)
        for i in range(1, len(re)):
            result = min(abs(re[i]-re[i-1]), result)
        return result


    def inorder(self, root, result):
        if not root:
            return
        self.inorder(root.left, result)
        result.append(root.val)
        self.inorder(root.right, result)


if __name__ == '__main__':
    test = Solution()
    root = [[4, 2, 6, 1, 3], [1, 0, 48, 'null', 'null', 12, 49]]
    for i in root:
        tree = test.create_tree(i)
        print(test.getMinimumDifference(tree), test.getMinimumDifference1(tree))

第二题

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

    假定 BST 满足如下定义：
    结点左子树中所含节点的值 小于等于 当前节点的值
    结点右子树中所含节点的值 大于等于 当前节点的值
    左子树和右子树都是二叉搜索树


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

    示例 2：
    输入：root = [0]
    输出：[0]

思路

同上第一题，二叉搜索树使用中序遍历得到的是递增的有序序列，众数一定会相邻，如果相邻两个数不相等，则这个数一定不是众数

代码

import collections
from math import inf


class TreeNode:
    def __init__(self, val, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right


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

    假定 BST 满足如下定义：
    结点左子树中所含节点的值 小于等于 当前节点的值
    结点右子树中所含节点的值 大于等于 当前节点的值
    左子树和右子树都是二叉搜索树


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

    示例 2：
    输入：root = [0]
    输出：[0]
    """

    def create_tree(self, root):
        if not root:
            return None
        result = TreeNode(root[0])
        queue = [result]
        i, n = 1, len(root)

        while i < n and queue:
            node = queue.pop(0)
            if i < n and root[i] != 'null':
                root_node = TreeNode(root[i])
                queue.append(root_node)
                node.left = root_node
            i += 1

            if i < n and root[i] != 'null':
                root_node = TreeNode(root[i])
                queue.append(root_node)
                node.right = root_node
            i += 1

        return result

    def findMode1(self, root):
        """
        迭代
        """
        if not root:
            return
        result = []
        stack = []
        pre = None
        con, max_con = 0, 0
        while root or stack:
            if root:
                stack.append(root)
                root = root.left
            else:
                node = stack.pop()
                # 搜索树中序遍历是一个递增有序序列，出现众数只会在相邻节点
                if pre and pre.val == node.val:
                    con += 1
                else:
                    con = 1
                if con == max_con:
                    result.append(node.val)
                elif con > max_con:
                    result = [node.val]
                    max_con += 1
                pre = node
                root = node.right
        return result

    def findMode(self, root):
        """
        递归
        """
        if not root:
            return
        re = []
        con, max_con = 1, 1
        self.inorder(root, re)
        result = [re[0]]
        pre = re[0]

        for i in range(1, len(re)):
            node = re[i]
            if pre == node:
                con += 1
            else:
                con = 1
            if con == max_con:
                result.append(node)
            elif con > max_con:
                max_con = con
                result = [node]
            pre = node
        return result

    def inorder(self, root, result):
        if not root:
            return
        self.inorder(root.left, result)
        result.append(root.val)
        self.inorder(root.right, result)


if __name__ == '__main__':
    test = Solution()
    root = [[1, 'null', 2, 2], [0]]
    for i in root:
        tree = test.create_tree(i)
        print(test.findMode(tree), test.findMode1(tree))

第三题

    给定一个二叉树, 找到该树中两个指定节点的最近公共祖先。
    百度百科中最近公共祖先的定义为：“对于有根树 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

思路

1.root等于p或q，则root即为所求
2.递归找左右子树
3.左子树找不到时：右子树可能找不到也可能找到，不管哪种情况直接返回右子树的结果即可
4. 右子树找不到时：左子树可能找不到也可能找到，不管哪种情况直接返回左子树的结果即可
5.左右子树的查询均不为空，则当前结点即为p、q的公共祖先节点
6.前序遍历

代码

本地调试容易犯错的是把p、q当作数值传递，实际上p、q是树结点

import collections
from math import inf


class TreeNode:
    def __init__(self, val, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right


class Solution:
    """
    给定一个二叉树, 找到该树中两个指定节点的最近公共祖先。
    百度百科中最近公共祖先的定义为：“对于有根树 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
    """

    def create_tree(self, root):
        if not root:
            return None
        result = TreeNode(root[0])
        queue = [result]
        i, n = 1, len(root)

        while i < n and queue:
            node = queue.pop(0)
            if i < n and root[i] != 'null':
                root_node = TreeNode(root[i])
                queue.append(root_node)
                node.left = root_node
            i += 1

            if i < n and root[i] != 'null':
                root_node = TreeNode(root[i])
                queue.append(root_node)
                node.right = root_node
            i += 1

        return result

    def lowestCommonAncestor(self, root, p, q):
        """
        1.root等于p或q，则root即为所求
        2.递归找左右子树
        3.左子树找不到时：右子树可能找不到也可能找到，不管哪种情况直接返回右子树的结果即可
        4. 右子树找不到时：左子树可能找不到也可能找到，不管哪种情况直接返回左子树的结果即可
        5.左右子树的查询均不为空，则当前结点即为p、q的公共祖先节点
        6.前序遍历
        """
        if not root or root == p or root == q:
            return root
        left = self.lowestCommonAncestor(root.left, p, q)
        right = self.lowestCommonAncestor(root.right, p, q)
        if not left:
            return right
        if not right:
            return left
        return root

    def find_node_by_val(self, node, val):
        if node is None:
            return None
        if node.val == val:
            return node
        return self.find_node_by_val(node.left, val) or self.find_node_by_val(node.right, val)


if __name__ == '__main__':
    test = Solution()
    root = [[3, 5, 1, 6, 2, 0, 8, 'null', 'null', 7, 4], [3, 5, 1, 6, 2, 0, 8, 'null', 'null', 7, 4], [1, 2]]
    p = [5, 5, 1]
    q = [1, 4, 2]
    for i in range(len(root)):
        tree = test.create_tree(root[i])
        p_node = test.find_node_by_val(tree, p[i])
        q_node = test.find_node_by_val(tree, q[i])
        print(test.lowestCommonAncestor(tree, p_node, q_node).val)