超琐碎 ≈ 完整记录 + 深入探究 + 任性吐槽
问题地址，难度：Normal，标签：Tree
若有错误之处请予以指正:)
问题描述
Given the root node of a binary search tree, return the sum of values of all nodes with value between L and R (inclusive).
The binary search tree is guaranteed to have unique values.
Example 1:
Input: root = [10,5,15,3,7,null,18], L = 7, R = 15
Output: 32
Example 2:
Input: root = [10,5,15,3,7,13,18,1,null,6], L = 6, R = 10
Output: 23
Note:
The number of nodes in the tree is at most 10000.
The final answer is guaranteed to be less than 2^31.
题意分析
这道题需要了解二叉搜索树的定义，以及递归/循环的知识。
我的实现及调优过程
方法1：356 ms
方法1我的思路是先看[L, R]这个range能不能卡住当前节点，即当前节点值v在[L,R]内。
- 如果在
[L,R]内，当前的range_sum = (v+ 左子树range_sum + 右子树rang_sum) - 如果不在
[L,R]内- 如果整个
[L,R]都在v右边，那么：当前的range_sum = 右子树range_sum - 如果整个
[L,R]都在v左边，那么：当前的range_sum = 左子树range_sum
- 如果整个
这样从根节点向下，每一个被遍历节点的range_sum都被算出来，最后加回到根节点。注意不是所有节点都会被遍历，因为v不在[L,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 rangeSumBST(self, root, L, R):
"""
:type root: TreeNode
:type L: int
:type R: int
:rtype: int
"""
range_sum = getRangeSum(root, L, R)
return range_sum
def getRangeSum(node, L, R):
if node is None:
return 0
if node.val > R:
range_sum = getRangeSum(node.left, L, R)
elif node.val < L:
range_sum = getRangeSum(node.right, L, R)
else:
range_sum = node.val + \
getRangeSum(node.left, L, R) + \
getRangeSum(node.right, L, R)
return range_sum
- 时间复杂度：O(n) （
n为树的节点数，最坏情况下每个节点都被遍历） - 空间复杂度：O(m) （递归本身的栈会占用一些资源，
m为树的深度，影响栈的数量）
方法2：356 ms
方法2是Leetcode上的Solution，思路是先初始化了一个self.ans为0，然后逐个遍历节点，每遇到一个在[L,R]内的节点，就做一次加法累进self.ans。
具体的做法：
- 判断当前节点是否在
[L,R]内，在的话self.ans加上当前节点值，不在的话继续步骤2和3 - 判断左子树是否可能存在符合要求的节点。根据二叉搜索树定义，左子树中任意的节点
w都满足w<v，而我们要的节点要求是[L, R]。如果L<v，那么可能存在w>=L，即w落在[L, v)范围内，这时只要再满足w<=R(v<=RORw<=R)，w就落进了[L,R]。注意须同时满足三个条件：L<vANDw>=LAND (v<=ROR w<=R)，第一个条件使用if确保，但由于我们在该步还没有访问w，无法确定第二、三个条件的真假，所以继续搜索左子树 - 同样地，考虑与2中相似的情况，我们在该步无法判断
w<=R的真假，所以继续搜索右子树
注意这种方法同样不一定会遍历所有节点。同时可以看到，这种解法的实现逻辑看似比上一种简单，但是需要经过严密的分析才能证明其正确性。另外引用王垠的观点，这种连续几个if没有else的写法也是有风险的（终于为自己为什么没有想到这种解法找到了充分理由LOL）
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
class Solution(object):
def rangeSumBST(self, root, L, R):
def dfs(node):
if node:
if L <= node.val <= R:
self.ans += node.val
if L < node.val:
dfs(node.left)
if node.val < R:
dfs(node.right)
self.ans = 0
dfs(root)
return self.ans
- 时间复杂度：O(n) （
n为树的节点数，最坏情况下每个节点都被遍历） - 空间复杂度：O(m) （递归本身的栈会占用一些资源，
m为树的深度，影响栈的数量）
方法3：227 ms
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, val=0, left=None, right=None):
# self.val = val
# self.left = left
# self.right = right
class Solution:
def rangeSumBST(self, root: Optional[TreeNode], low: int, high: int) -> int:
def rangeSum(t):
_sum = 0
if not t:
return _sum
elif t.val < low:
_sum += rangeSum(t.right)
elif t.val > high:
_sum += rangeSum(t.left)
else:
_sum += t.val + rangeSum(t.left) + rangeSum(t.right)
return _sum
return rangeSum(root)
2022重刷，思路同1，接口简单一点
- 时间复杂度：O(n) （
n为树的节点数，最坏情况下每个节点都被遍历） - 空间复杂度：O(m) （递归本身的栈会占用一些资源，
m为树的深度，影响栈的数量）
