leetcode 938. Range Sum of BST

题目

给定一颗二叉搜索树的根节点，返回节点值在L和R之间（包括L和R）的节点值的和。

思路

写了一个完整的二叉搜索树，调整一下中序遍历的方法比较L和R就行了，注意在递归调用时要写上L和R这两个参数。如果是没有重复数字的BST，可以在递归查找左叶子之后比较一下R和右叶子的值，如果完全相等就早停，速度快了一倍。

代码

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None


class Solution:
    def __init__(self):
        self.x= 0

    def rangeSumBST(self, root, L, R):
        """
        :type root: TreeNode
        :type L: int
        :type R: int
        :rtype: int
        """
        if root.left:
            self.rangeSumBST(root.left, L, R)
        if L <= root.val <= R:
            self.x += root.val
            if root.val == R:
                return self.x
        if root.right:
            self.rangeSumBST(root.right, L, R)
        return self.x

其他

二叉搜索树的简单实现

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


class BinarySearchTree:
    def __init__(self):
        self.root = None
        self.elements = []

    def __repr__(self):
        if self.is_empty():
            return 'empty tree'
        else:
            self.elements = []
            self.traverse_mid_first()
            return ' '.join(str(a) for a in self.elements)

    def is_empty(self):
        return False if self.root else True

    def traverse_mid_first(self, node=None, start=float('-inf'), end=float('inf')):
        if not node:
            node = self.root

        if node.left:
            self.traverse_mid_first(node.left, start, end)
        if start <= node.val <= end:
            self.elements.append(node.val)
        if node.right:
            self.traverse_mid_first(node.right, start, end)

    def insert(self, x):
        new_node = TreeNode(x)
        if not self.root:
            self.root = new_node
            return
        current_node, temp_node = self.root, self.root
        while current_node:
            temp_node = current_node
            if x < current_node.val:
                current_node = current_node.left
            else:
                current_node = current_node.right

        if x < temp_node.val:
            temp_node.left = new_node
        if x > temp_node.val:
            temp_node.right = new_node