leetcode树之二叉搜索树

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

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

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

示例1：

输入: root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 8
输出: 6 

示例2：

输入: root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 4
输出: 2

---

思路：

如果p，q结点一个在左子树，一个在右子树，那么说明该节点是p，q的最近公共祖先，如果在同一个子树，进行遍历即可。

class Solution:
    def lowestCommonAncestor(self, root: 'TreeNode', p: 'TreeNode', q: 'TreeNode') -> 'TreeNode':
        if not root: return root
        # p,q的值都小于root的值，说明都在左子树，都大于root的值说明在右子树，迭代即可
        # 否则那么说明该节点是最近公共祖先
        if p.val < root.val and q.val < root.val:
            root = root.left
        elif p.val > root.val and q.val > root.val:
            root = root.right
        else:
            return root
        return self.lowestCommonAncestor(root, p, q)

501、二叉搜索树中的众数

给你一个含重复值的二叉搜索树（BST）的根节点 root ，找出并返回 BST 中的所有 众数（即，出现频率最高的元素）。

如果树中有不止一个众数，可以按 任意顺序 返回。

假定 BST 满足如下定义：

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

示例1：

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

示例2：

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

---

思路：

二叉搜索树中序遍历是递增的，可以通过递增序列来进行统计众数

class Solution:
    def __init__(self):
        self.base = None
        self.count = 0
        self.maxCount = 0
        self.ans = []

    def update(self, value):
      	# 如果base和value相等，说明count记录的值是base的值，那么计数即可，如果不同，那么需要重新计数
        if self.base == value:
            self.count += 1
        else:
            self.count = 1
            self.base = value
        # 比较是否计数超过当前最大计数，如果相等，那么说明有相同个数的值，追加到结果集即可
        if self.count == self.maxCount:
            self.ans.append(self.base)
        # 如果计数大于最大计数，那么之前的结果集需要作废
        if self.count > self.maxCount:
            self.maxCount = self.count
            self.ans = [self.base]

    def findMode(self, root: TreeNode) -> List[int]:
      	# 中序遍历
        def dfs(root):
            if not root: return
            dfs(root.left)
            self.update(root.val)
            dfs(root.right)
        dfs(root)
        return self.ans

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

给你一个二叉搜索树的根节点 root ，返回 树中任意两不同节点值之间的最小差值 。

差值是一个正数，其数值等于两值之差的绝对值。

示例1：

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

示例2：

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

---

思路：

由于二叉搜索树中序遍历序列是递增的，而递增序列的最小差值肯定是递增的两个值之间的最小差，可以通过中序遍历求当前节点和上一个节点的绝对差

class Solution:
    def getMinimumDifference(self, root: TreeNode) -> int:
        self.pre = None
        self.min_diff = float("inf")
        def dfs(root):
            if not root: return
            dfs(root.left)
            # 如果前一个结点存在则进行最小值的计算
            if self.pre:
                self.min_diff = min(self.min_diff, abs(root.val - self.pre.val))
            self.pre = root
            dfs(root.right)
        dfs(root)
        return self.min_diff

938、二叉搜索树的范围和

给定二叉搜索树的根结点 root，返回值位于范围 [low, high] 之间的所有结点的值的和。

示例1：

输入：root = [10,5,15,3,7,null,18], low = 7, high = 15
输出：32

示例2：

输入：root = [10,5,15,3,7,13,18,1,null,6], low = 6, high = 10
输出：23

---

思路：

中序遍历，在范围内的值进行求和

class Solution:
    def rangeSumBST(self, root: TreeNode, low: int, high: int) -> int:
        stack = []
        cur = root
        range_sum = 0
        while cur or stack:
            while cur:
                stack.append(cur)
                cur = cur.left
            cur = stack.pop()
            if low <= cur.val <= high:
                range_sum += cur.val
            if high < cur.val: break
            cur = cur.right
        return range_sum

递归进行范围求和

class Solution:
    def rangeSumBST(self, root: TreeNode, low: int, high: int) -> int:
        if not root: return 0
        # 如果根节点大于high，说明范围值都在左子树
        if root.val > high:
            return self.rangeSumBST(root.left, low, high)
        # 如果根节点小于low，说明范围值都在右子树
        if root.val < low:
            return self.rangeSumBST(root.right, low, high)
        return root.val + self.rangeSumBST(root.left, low, high) + self.rangeSumBST(root.right, low, high)