二叉搜索树基础概念与经典题目（Leetcode题解-Python语言）

二叉搜索树，首先上定义：

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

而二叉搜索树最有用的性质就是，对其中序遍历可以得到一个递增的有序序列。更多的内容，可以到这个Leetbook当中学习。

700. 二叉搜索树中的搜索

递归法：

class Solution:
    def searchBST(self, root: TreeNode, val: int) -> TreeNode:
        while root and root.val != val:
            root = root.left if root.val > val else root.right
        return root

迭代法：

class Solution:
    def searchBST(self, root: TreeNode, val: int) -> TreeNode:
        node = root
        while node:
            if val < node.val:
                node = node.left
            elif val > node.val:
                node = node.right
            else:
                return node
        return None

简单题，目标数值大于当前节点值的话去右子树，小于当前节点值的话去左子树，直到目标数值等于当前节点值。

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

递归法：

class Solution:
    def insertIntoBST(self, root: TreeNode, val: int) -> TreeNode:
        if not root:
            return TreeNode(val)
        
        if val < root.val:
            root.left = self.insertIntoBST(root.left, val)
        else:
            root.right = self.insertIntoBST(root.right, val)
        return root 

迭代法：

class Solution:
    def insertIntoBST(self, root: TreeNode, val: int) -> TreeNode:
        if not root:
            return TreeNode(val)
        
        node = root
        while node:
            if val < node.val:
                if node.left:
                    node = node.left
                else:
                    node.left = TreeNode(val)
                    break
            else:
                if node.right:
                    node = node.right
                else:
                    node.right = TreeNode(val)
                    break
        return root

同样的，由于二叉搜索树自带大小关系，所以一个元素只要根据大小关系迭代进入左右子树，找到的空节点即为要插入的节点位置。

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

class Solution:
    def deleteNode(self, root: Optional[TreeNode], key: int) -> Optional[TreeNode]:
        if not root:
            return root
        
        # 要删除的节点在左子树
        if key < root.val:
            root.left = self.deleteNode(root.left, key)
            return root
        # 要删除的节点在右子树
        elif key > root.val:
            root.right = self.deleteNode(root.right, key)
            return root
        # 找到了要删除的节点
        else:
            # 1、如果节点的左子树为空，就用右子树替代它自己
            if not root.left:
                return root.right
            # 2、如果节点的右子树为空，就用左子树替代它自己
            elif not root.right:
                return root.left
            # 3、节点的左右子树都不为空，则用它的后继节点替代它自己
            else:
                cur = root.right
                while cur.left:
                    cur = cur.left
                # 将待删除节点的左子树接到其后继节点的左边，然后返回其右子树
                cur.left = root.left
                return root.right

这里有个知识点，在中序遍历里面，一个节点的前驱节点（仅小于待删除节点的节点）是其左节点的最右节点（右到底），一个节点的后继节点（仅大于待删除节点的节点）是其右节点的最左节点（左到底）。删除节点分三类情况讨论。

98. 验证二叉搜索树（面试题 04.05. 合法二叉搜索树）

验证二叉搜索树，第一种方法是从定义出发：

class Solution:
    def isValidBST(self, root: TreeNode) -> bool:
        def bounder(lower, node: TreeNode, upper) -> bool:
            if not node:
                return True        
            val = node.val
            if val <= lower or val >= upper:
                return False
            
            return bounder(lower, node.left, val) and bounder(val, node.right, upper)
            
        return bounder(float('-inf'), root, float('inf'))

使用递归函数判断二叉搜素树是否符合定义，同时传入边界作为参数。

第二种方法是根据二叉搜索树的性质，即中序遍历得到递增序列：

class Solution:
    def isValidBST(self, root: TreeNode) -> bool:
        self.temp = float('-inf')
        self.isValid = True

        def inorder(root: TreeNode):
            if not root:
                return
            inorder(root.left)  # 左根右
            if root.val <= self.temp:
                self.isValid = False
            self.temp = root.val
            inorder(root.right)
        
        inorder(root)
        return self.isValid

递归写法要使用到全局变量，比较麻烦，建议用统一的迭代写法：

class Solution:
    def isValidBST(self, root: TreeNode) -> bool:
        stack = []
        stack.append(root)
        pre = None 
        while stack:
            node = stack.pop()
            if node:
                if node.right:
                    stack.append(node.right)
                stack.append(node)
                stack.append(None)
                if node.left:
                    stack.append(node.left)
            else:
                node = stack.pop()
                if pre and pre.val >= node.val:
                    return False
                pre = node
        return True 

剑指 Offer 54. 二叉搜索树的第k大节点

class Solution:
    def kthLargest(self, root: TreeNode, k: int) -> int:
        ans = []
        if not root:
            return None
        stack = []
        stack.append(root)
        while stack:
            node = stack.pop()
            if node:
                if node.right:
                    stack.append(node.right)
                stack.append(node)
                stack.append(None)
                if node.left:
                    stack.append(node.left)
            else:
                node = stack.pop()
                ans.append(node.val)
        return ans[-k]

中序遍历得到递增序列，然后取倒数第k个即为第k大的节点值。

230. 二叉搜索树中第K小的元素

class Solution:
    def kthSmallest(self, root: Optional[TreeNode], k: int) -> int:
        ans = []
        if not root:
            return None
        stack = []
        stack.append(root)
        while stack:
            node = stack.pop()
            if node:
                if node.right:
                    stack.append(node.right)
                stack.append(node)
                stack.append(None)
                if node.left:
                    stack.append(node.left)
            else:
                node = stack.pop()
                ans.append(node.val)
        return ans[k-1]

还是中序遍历，由于是取第 k 小，所有也可以遍历 k 个节点后直接跳出循环。

530. 二叉搜索树的最小绝对差（783. 二叉搜索树节点最小距离）

class Solution:
    def getMinimumDifference(self, root: TreeNode) -> int:
        if not root:
            return None
        ans = 100001
        pre = None
        stack = []
        stack.append(root)
        while stack:
            node = stack.pop()
            if node:
                if node.right:
                    stack.append(node.right)
                stack.append(node)
                stack.append(None)
                if node.left:
                    stack.append(node.left)
            else:
                node = stack.pop()
                if pre and abs(pre.val - node.val) < ans:
                    ans = abs(pre.val - node.val)
                pre = node
        return ans

还是中序遍历，用 pre 记录前面的节点，用 ans 记录最小的相邻数字之差绝对值。

501. 二叉搜索树中的众数

class Solution:
    def findMode(self, root: TreeNode) -> List[int]:
        if not root:
            return None
        ans = []
        maxCount = 0
        count = 0
        pre = None
        stack = []
        stack.append(root)
        while stack:
            node = stack.pop()
            if node:
                if node.right:
                    stack.append(node.right)
                stack.append(node)
                stack.append(None)
                if node.left:
                    stack.append(node.left)
            else:
                node = stack.pop()
                # 如果前面有节点且两者的值相同，就 count + 1，否则就是一个新的数
                if pre and pre.val == node.val:
                    count += 1
                else:
                    count = 1
                # 如果当前的数出现次数恰好等于 maxCount，那就加到 ans 中
                if count == maxCount:
                    ans.append(node.val)
                # 如果当前的数出现次数大于 maxCount，那就是新的众数
                elif count > maxCount:
                    maxCount = count
                    ans = [node.val]
                pre = node
        return ans

还是中序遍历，用 pre 记录前面的节点，用 count 记录当前数出现的次数，用 maxCount 记录出现最多的数字的出现次数，用 ans 记录出现最多的数字（可能有多个众数）。

235. 二叉搜索树的最近公共祖先（剑指 Offer 68 - I. 二叉搜索树的最近公共祖先）

class Solution:
    def lowestCommonAncestor(self, root: 'TreeNode', p: 'TreeNode', q: 'TreeNode') -> 'TreeNode':
        node = root
        while node:
            if p.val < node.val and q.val < node.val:
                node = node.left
            elif p.val > node.val and q.val > node.val:
                node = node.right
            else:
                return node
        return None

要找到两个节点的最近公共祖先，只需要从根节点开始，同时对两个节点进行搜索，让他们一起移动，直到第一次出现分歧点，即为最近公共祖先。

255. 验证前序遍历序列二叉搜索树

class Solution:
    def verifyPreorder(self, preorder: List[int]) -> bool:
        stack = []
        root = float('-inf')
        for i in range(len(preorder)):
            if preorder[i] <= root: # 下一个节点必须比root值大，否则返回False
                return False
            while stack and stack[-1] < preorder[i]:  # 找到右子树对应的根节点root值，下一个节点必须比这个值大
                root = stack.pop()
            stack.append(preorder[i])
        return True

前序遍历序列，就是根左右，会先一直遍历左子树到底，若是二叉搜索树，则必定是个递减序列；然后出现第一个比前面的数大的，肯定是遍历了右子树，本题关键就在此，这个右子树不仅要比前一个数（左子树）大，还要比其根节点（父节点）大。因此，用一个栈记录遍历过的前序序列，递减时正常记录，每当出现递增的时候，都要找到前面序列中仅次于右子树的值（根节点），再后一个值是必须大于这个值的，否则返回False。

剑指 Offer 33. 二叉搜索树的后序遍历序列

class Solution:
    def verifyPostorder(self, postorder: List[int]) -> bool:
        stack = []
        root = float('+inf')
        for i in range(len(postorder) - 1, -1, -1):
            if postorder[i] >= root:
                return False
            while stack and stack[-1] > postorder[i]: 
                root = stack.pop()
            stack.append(postorder[i])
        return True

与上一题类似，后序遍历是左右根，序列是先递增再递减，还是在递增转折为递减的时候，判断转折节点与其根节点的关系。推荐题解看这篇。

1008. 前序遍历构造二叉搜索树

class Solution:
    def bstFromPreorder(self, preorder: List[int]) -> TreeNode:
        if preorder:
            leftTree = []
            rightTree = []
            root = TreeNode(preorder.pop(0))
            for val in preorder:
                if val > root.val:
                    rightTree.append(val)
                else:
                    leftTree.append(val)
            root.left = self.bstFromPreorder(leftTree)
            root.right = self.bstFromPreorder(rightTree)
            return root

从前序遍历序列构造二叉搜索树，思路就是递归，利用二叉搜索树的特点，将小于当前节点的作为左子树，大于当前节点的作为右子树即可。

95. 不同的二叉搜索树 II

class Solution:
    def generateTrees(self, n: int) -> List[TreeNode]:
        def helper(start, end):
            if start > end:
                return [None]
            allTrees = []

            for i in range(start, end+1):
                leftTrees = helper(start, i-1)
                rightTrees = helper(i+1, end)
            
                for l in leftTrees:
                    for r in rightTrees:
                        curTree = TreeNode(i)
                        curTree.left = l
                        curTree.right = r
                        allTrees.append(curTree)
            
            return allTrees
            
        return helper(1, n) if n else []

我们定义 helper(start, end) 函数表示当前值的集合为 [start,end]，返回序列 [start,end] 生成的所有可行的二叉搜索树。在每次递归中，我们枚举 [start,end] 中的值 i 为当前二叉搜索树的根，那么序列划分为了 [start,i−1] 和 [i+1,end] 两部分。我们递归调用这两部分，即 helper(start, i - 1) 和 helper(i + 1, end)，获得所有可行的左子树和可行的右子树，那么最后一步我们只要从可行左子树集合中选一棵，再从可行右子树集合中选一棵拼接到根节点上，并将生成的二叉搜索树放入答案数组即可。

递归的入口即为 helper(1, n)，出口为当 start > end 的时候，当前二叉搜索树为空，返回空节点即可。

173. 二叉搜索树迭代器

这题最简单的思路是在__init__的时候进行一次中序遍历，把二叉搜索树的递增序列用队列记录下来，然后在next的时候返回队列首部的元素 popleft 即可。

class BSTIterator(object):

    def __init__(self, root):
        self.queue = collections.deque()
        self.inOrder(root)
    
    def inOrder(self, root):
        if not root: return
        self.inOrder(root.left)
        self.queue.append(root.val)
        self.inOrder(root.right)

    def next(self):
        return self.queue.popleft()

    def hasNext(self):
        return len(self.queue) > 0

更好的思路是迭代法：

class BSTIterator:

    def __init__(self, root: TreeNode):
        self.stack = []
        while root:
            self.stack.append(root)
            root = root.left

    def next(self) -> int:
        cur = self.stack.pop()
        node = cur.right
        while node:
            self.stack.append(node)
            node = node.left
        return cur.val

    def hasNext(self) -> bool:
        return len(self.stack) > 0

对比中序遍历的迭代写法，可以发现迭代器实际上是把中序遍历拆开分别执行了

    # 中序遍历
    def inorderTraversal(self, root: TreeNode) -> List[int]:
        ans = list()
        if not root:
            return ans     
               
        stack = list()
        node = root
        
        while stack or node:
            while node: # 当node的左子节点为空时停止
                stack.append(node)
                node = node.left
###########################################################
            node = stack.pop()	# 回溯
            ans.append(node.val)
            node = node.right	# 访问右子节点        
        return ans

在__init__的时候，执行到了上半部分；之后每次next，都会执行本次循环的下半部分和下一次循环的上半部分，即相当于用手动的next代替了while stack or node。

二叉搜索树主要支持三个操作：搜索、插入和删除。二叉搜索树的优点是，即便在最坏的情况下，也允许你在O(h)的时间复杂度内执行所有的搜索、插入、删除操作。通常来说，如果你想有序地存储数据或者需要同时执行搜索、插入、删除等多步操作，二叉搜索树这个数据结构是一个很好的选择。

938. 二叉搜索树的范围和

class Solution:
    def rangeSumBST(self, root: TreeNode, low: int, high: int) -> int:
        def inorder(node: TreeNode):
            if not node:
                return
            if node.val > low:
                inorder(node.left)
            if node.val <= high and node.val >= low:
                self.counter += node.val
            if node.val < high:
                inorder(node.right)
        
        self.counter = 0
        inorder(root)
        return self.counter

中序遍历二叉搜索树，只要节点值在范围内即累计到答案中，优化了的地方是当前节点值大于左边界才去遍历左子树（否则左子树都是比左边界小，越界），小于右边界才去遍历右子树（否则右子树都是比右边界大，越界）。

669. 修剪二叉搜索树

class Solution:
    def trimBST(self, root: TreeNode, low: int, high: int) -> TreeNode:
        def trim(node):
            if not node:
                return None
            elif node.val > high:  # 若当前节点值大于high，则它的右子树必大于high
                return trim(node.left)
            elif node.val < low:   # 若当前节点值小于low，则它的左子树必小于low
                return trim(node.right)
            else:
                node.left = trim(node.left)
                node.right = trim(node.right)
                return node

        return trim(root)

修剪的方法就是，如果当前节点值大于high，则它的右子树必大于high，只能返回其左子树；如果当前节点值小于low，则它的左子树必小low，只能返回其右子树。注意增加return node是因为根节点可能改变，否则就 trim(root) 然后 return root 就行了。

285. 二叉搜索树中的中序后继（剑指 Offer II 053. 二叉搜索树中的中序后继）（面试题 04.06. 后继者）

class Solution:
    def inorderSuccessor(self, root: 'TreeNode', p: 'TreeNode') -> 'TreeNode':
        if p.right:
            p = p.right
            while p.left:
                p = p.left
            return p
        
        stack = []
        node = root
        pre = float('-inf')
        
        while stack or node:
            while node:
                stack.append(node)
                node = node.left
            node = stack.pop()

            if pre == p.val: 
                return node
               
            pre = node.val     
            node = node.right

        return None

对于有右子树的节点，它的后继节点（递增序列中右边的元素）是其右节点的最左节点（左到底）。如果没有右子树，则其后继节点是其作为左子树时的父节点。如果节点即没有右子树，其自身又是右子树，则没有后继节点。

510. 二叉搜索树中的中序后继 II

class Solution:
    def inorderSuccessor(self, node: 'Node') -> 'Node':
        if node.right:
            node = node.right
            while node.left:
                node = node.left
            return node
        else:
            while node.parent and node == node.parent.right:
                node = node.parent
            return node.parent

本题的条件比上一题修改了一点，没有了根节点，但是多了父节点指针。思路还是一样，如果节点有右子树，其后继节点可以马上找到；如果没有，则寻找其父节点、父节点的父节点，一直到找到有父子关系是右子树的或者空节点为止。

653. 两数之和 IV - 输入 BST（剑指 Offer II 056. 二叉搜索树中两个节点之和）

class Solution:
    def findTarget(self, root: TreeNode, k: int) -> bool:
        
        def inorder(node: TreeNode):
            if not node:
                return 
            inorder(node.left)
            nums.append(node.val)
            inorder(node.right)

        nums = []
        inorder(root)
        
        left = 0
        right = len(nums) - 1
        while left < right:
            if nums[left] + nums[right] == k:
                return True
            elif nums[left] + nums[right] > k:
                right -= 1
            else:
                left += 1
        
        return False

还是先用中序遍历记录数组，得到递增序列，然后用双指针即可。

1214. 查找两棵二叉搜索树之和

class Solution:
    def twoSumBSTs(self, root1: TreeNode, root2: TreeNode, target: int) -> bool:        
        def inorder(node: TreeNode, nums):
            if not node:
                return 
            inorder(node.left, nums)
            nums.append(node.val)
            inorder(node.right, nums)

        nums1, nums2 = [], []
        inorder(root1, nums1)
        inorder(root2, nums2)     
        
        left = 0
        right = len(nums2) - 1
        while left < len(nums1) and 0 <= right:
            if nums1[left] + nums2[right] == target:
                return True
            elif nums1[left] + nums2[right] > target:
                right -= 1
            else:
                left += 1
 
        return False

与上一题类似，此题是要在两个二叉搜索树中找到两数之和，即做两次中序遍历，然后双指针分别遍历两个递增序列即可。

897. 递增顺序搜索树（剑指 Offer II 052. 展平二叉搜索树）（面试题 17.12. BiNode）

class Solution:
    def increasingBST(self, root: TreeNode) -> TreeNode:
        if not root:
            return None
        stack = []
        node = root
        newnode = 0
        while stack or node:
            while node:
                stack.append(node)
                node = node.left
            node = stack.pop()
            if newnode == 0:  # 第一个节点
                newnode = TreeNode(node.val)
                newroot = newnode
            else:
                newnode.right = TreeNode(node.val)
                newnode = newnode.right
            node = node.right
        return newroot

在中序遍历二叉搜索树的同时，用一个新的节点构建二叉树即可。

99. 恢复二叉搜索树

class Solution:
    def recoverTree(self, root: Optional[TreeNode]) -> None:
        firstNode = None
        secondNode = None
        pre = TreeNode(float("-inf"))

        stack = []
        node = root
        while node or stack:
            while node:
                stack.append(node)
                node = node.left
            node = stack.pop()
            if pre.val > node.val:
                if not firstNode:
                    firstNode = pre
                if firstNode:               
                    secondNode = node
            
            pre = node
            node = node.right
        
        firstNode.val, secondNode.val = secondNode.val, firstNode.val

中序遍历二叉搜索树，得到的一定是递增序列，如果有两个节点被错误交换，则反映在序列中一定是出现了递减的位置，找到这两个位置即可。

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

class Solution:
    def sortedArrayToBST(self, nums: List[int]) -> Optional[TreeNode]:
        n = len(nums)
        if n == 0:
            return None
        mid = n // 2
        root = TreeNode(nums[mid])
        root.left = self.sortedArrayToBST(nums[:mid])
        root.right = self.sortedArrayToBST(nums[mid+1:])
        return root

最直观的思路，每次取中间元素作为当前的根节点，两侧的元素作为左右子树递归建树，左侧区间 [:mid-1] 作为左子树，右侧区间 [mid+1:] 作为右子树。如果想节省点空间，那递归时用区间的指针代替区间也可以：

class Solution:
    def sortedArrayToBST(self, nums: List[int]) -> Optional[TreeNode]:
        def helper(left, right):
            if left > right:
                return None
            mid = (left + right) // 2
            root = TreeNode(nums[mid])
            root.left = helper(left, mid - 1)
            root.right = helper(mid + 1, right)
            return root

        return helper(0, len(nums) - 1)

538. 把二叉搜索树转换为累加树（1038. 把二叉搜索树转换为累加树）（剑指 Offer II 054. 所有大于等于节点的值之和）

递归法：

class Solution:
    def convertBST(self, root: Optional[TreeNode]) -> Optional[TreeNode]:
        total = 0
        def inorder(root: TreeNode):
            nonlocal total
            if not root:
                return
            inorder(root.right)
            total += root.val
            root.val = total
            inorder(root.left)
        
        inorder(root)
        return root

迭代法：

class Solution:
    def convertBST(self, root: Optional[TreeNode]) -> Optional[TreeNode]:
        if not root:
            return None
        stack = []
        stack.append(root)
        total = 0
        while stack:
            node = stack.pop()
            if node:
                if node.left:
                    stack.append(node.left)
                stack.append(node)
                stack.append(None)
                if node.right:
                    stack.append(node.right)
            else:
                node = stack.pop()
                total += node.val
                node.val = total
        return root

本题要求我们将每个节点的值修改为原来的节点值加上所有大于它的节点值之和。我们只需要反序中序遍历该二叉搜索树（即右根左），记录过程中的节点值之和，并不断更新当前遍历到的节点的节点值，即可得到题目要求的累加树。

426. 将二叉搜索树转化为排序的双向链表（剑指 Offer 36. 二叉搜索树与双向链表）

class Solution:
    def treeToDoublyList(self, root: 'Node') -> 'Node':
        if not root:
            return None

        def inorder(node):
            nonlocal first, last
            if not node:
                return
            inorder(node.left)
            if not first:
                first = node
            else:
                last.right = node
                node.left = last
            last = node
            inorder(node.right)
        
        first, last = None, None
        inorder(root)
        last.right = first
        first.left = last
        return first

使用两个指针，一个头指针一个尾指针，初始均为空。然后中序遍历二叉搜索树，如果头指针为空则把该节点设为头节点，否则就先建立当前节点与下一个节点的双向联系，然后移动到下一个节点。遍历完成后，再补上尾节点与头节点的联系即可。