【python刷题】二叉搜索树-相关题目

二叉搜索树的重要性质：中序遍历的结果是升序排列。

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

class Solution:
    def __init__(self):
        self.res = 0
        self.rank = 0

    def kthSmallest(self, root: TreeNode, k: int) -> int:
        self.traverse(root, k)
        return self.res
    
    def traverse(self, root , k):
        if not root:
            return 
        self.traverse(root.left, k)
        self.rank = self.rank + 1
        if self.rank == k:
            self.res = root.val
            return 
        self.traverse(root.right, k)

leetcode 538 把二叉搜索树转换为累加树

class Solution:
    def __init__(self):
        self.s = 0
    def convertBST(self, root: TreeNode) -> TreeNode:
        self.traverse(root)
        return root
    def traverse(self, root):
        if not root:
            return 
        self.convertBST(root.right)
        self.s = self.s + root.val
        root.val = self.s
        self.convertBST(root.left)

606. 根据二叉树创建字符串

class Solution:
    def tree2str(self, t: TreeNode) -> str:
        def traverse(root):
            if not root:
                return ""
            if not root.left and not root.right:
                return str(root.val) + ""
            if not root.right:
                return str(root.val) + "(" + traverse(root.left) + ")"
            return str(root.val) + "(" + traverse(root.left) + ")(" + traverse(root.right) + ")
        return traverse(t)

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

class Solution:
    def __init__(self):
        self.res = float("inf")
        self.pre = -1
    def getMinimumDifference(self, root: TreeNode) -> int:
        def traverse(root):
            if not root:
                return 0
            traverse(root.left)
            if self.pre != -1 and abs(root.val - self.pre) < self.res:
                self.res = abs(root.val - self.pre)
            self.pre = root.val
            traverse(root.right)
        traverse(root)
        return self.res

剑指offer：二叉搜索树的后序遍历序列

输入一个整数数组，判断该数组是不是某二叉搜索树的后序遍历的结果。如果是则返回true,否则返回false。假设输入的数组的任意两个数字都互不相同。（ps：我们约定空树不是二叉搜素树）

# -*- coding:utf-8 -*-
class Solution:
    def VerifySquenceOfBST(self, sequence):
        # write code here
        if not sequence:
            return False
        root = sequence[-1]
        n = len(sequence) - 1
        sp = len(sequence) - 1
        for i in range(n):
            if sequence[i] > root:
                sp = i
                break
        for j in range(sp, n):
            if sequence[j] < root:
                return False
        left = True
        if sp > 0:
            left = self.VerifySquenceOfBST(sequence[:sp])
        right = True
        if sp < n:
            right = self.VerifySquenceOfBST(sequence[sp:n])
        return left and right

剑指offer：二叉树的和为某一值的路径

输入一颗二叉树的根节点和一个整数，按字典序打印出二叉树中结点值的和为输入整数的所有路径。路径定义为从树的根结点开始往下一直到叶结点所经过的结点形成一条路径

# -*- coding:utf-8 -*-
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
class Solution:
    def FindPath(self, root, expectNumber):
        # write code here
        target = expectNumber
        if not root:
            return []
        res = []
        path = []
        self.Find(root,target,res,path)
        return res
    
    def Find(self,root,target,res,path):
        if not root:
            return
        path.append(root.val)
        isleaf = root.left is None and root.right is None
        if isleaf and root.val == target:
            res.append(path[:])
        if root.left:
            self.Find(root.left, target - root.val, res, path)
        if root.right:
            self.Find(root.right, target - root.val, res, path)
        path.pop()