LC 938. 二叉搜索树的范围和

题目描述

这是 LeetCode 上的 938. 二叉搜索树的范围和 ，难度为 简单。

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

示例 1：

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

输出：32

示例 2：

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

输出：23

提示：

  • 树中节点数目在范围 $[1, 2 \times 10^4$] 内
  • $1 <= Node.val <= 10^5$
  • $1 <= low <= high <= 10^5$
  • 所有 Node.val 互不相同

基本思路

这又是众多「二叉搜索树遍历」题目中的一道。

二叉搜索树的中序遍历是有序的。

只要对其进行「中序遍历」即可得到有序列表，在遍历过程中判断节点值是否符合要求，对于符合要求的节点值进行累加即可。

二叉搜索树的「中序遍历」有「迭代」和「递归」两种形式。由于给定了值范围 $[low, high]$，因此可以在遍历过程中做一些剪枝操作，但并不影响时空复杂度。

递归

递归写法十分简单，属于树的遍历中最简单的实现方式。

Java 代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
class Solution {
    int low, high, ans;
    public int rangeSumBST(TreeNode root, int _low, int _high) {
        low = _low; high = _high;
        dfs(root);
        return ans;
    }
    void dfs(TreeNode root) {
        if (root == null) return;
        dfs(root.left);
        if (low <= root.val && root.val <= high) ans += root.val;
        dfs(root.right);
    }
}

C++ 代码：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
class Solution {
public:
    int low, high, ans;
    int rangeSumBST(TreeNode* root, int _low, int _high) {
        low = _low; high = _high;
        dfs(root);
        return ans;
    }
    void dfs(TreeNode* root) {
        if (!root) return;
        dfs(root->left);
        if (low <= root->val && root->val <= high) ans += root->val;
        dfs(root->right);
    }
};

Python 代码：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
class Solution:
    def rangeSumBST(self, root: TreeNode, _low: int, _high: int) -> int:
        self.low = _low
        self.high = _high
        self.ans = 0
        self.dfs(root)
        return self.ans

    def dfs(self, root):
        if not root:
            return
        self.dfs(root.left)
        if self.low <= root.val <= self.high:
            self.ans += root.val
        self.dfs(root.right)

  • 时间复杂度：$O(n)$
  • 空间复杂度：$O(n)$

迭代

迭代其实就是使用「栈」来模拟递归过程，也属于树的遍历中的常见实现形式。

一般简单的面试中如果问到树的遍历，面试官都不会对「递归」解法感到满意，因此掌握「迭代/非递归」写法同样重要。

Java 代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
class Solution {
    public int rangeSumBST(TreeNode root, int low, int high) {
        int ans = 0;
        Deque<TreeNode> d = new ArrayDeque<>();
        while (root != null || !d.isEmpty()) {
            while (root != null) {
                d.addLast(root);
                root = root.left;
            }
            root = d.pollLast();
            if (low <= root.val && root.val <= high) ans += root.val;
            root = root.right;
        }
        return ans;
    }
}

C++ 代码：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
class Solution {
public:
    int rangeSumBST(TreeNode* root, int low, int high) {
        int ans = 0;
        deque<TreeNode*> d;
        while (root != nullptr || !d.empty()) {
            while (root != nullptr) {
                d.push_back(root);
                root = root->left;
            }
            root = d.back();
            d.pop_back();
            if (low <= root->val && root->val <= high) ans += root->val;
            root = root->right;
        }
        return ans;
    }
};

Python 代码：
1
2
3
4
5
6
7
8
9
10
11
12
13
class Solution:
    def rangeSumBST(self, root: TreeNode, low: int, high: int) -> int:
        ans = 0
        stk = []
        while root is not None or stk:
            while root is not None:
                stk.append(root)
                root = root.left
            root = stk.pop()
            if low <= root.val <= high:
                ans += root.val
            root = root.right
        return ans

  • 时间复杂度：$O(n)$
  • 空间复杂度：$O(n)$

最后

这是我们「刷穿 LeetCode」系列文章的第 No.938 篇，系列开始于 2021/01/01，截止于起始日 LeetCode 上共有 1916 道题目，部分是有锁题，我们将先把所有不带锁的题目刷完。

在这个系列文章里面，除了讲解解题思路以外，还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。

为了方便各位同学能够电脑上进行调试和提交代码，我建立了相关的仓库：https://github.com/SharingSource/LogicStack-LeetCode 。

在仓库地址里，你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。