Ecosyste.ms: Awesome
An open API service indexing awesome lists of open source software.
https://github.com/emahtab/range-sum-of-bst
Range Sum of BST
https://github.com/emahtab/range-sum-of-bst
binary-search-tree leetcode problem-solving
Last synced: about 1 month ago
JSON representation
Range Sum of BST
- Host: GitHub
- URL: https://github.com/emahtab/range-sum-of-bst
- Owner: eMahtab
- Created: 2020-02-06T18:18:53.000Z (almost 5 years ago)
- Default Branch: master
- Last Pushed: 2024-10-17T13:04:33.000Z (3 months ago)
- Last Synced: 2024-10-19T17:26:55.483Z (3 months ago)
- Topics: binary-search-tree, leetcode, problem-solving
- Homepage:
- Size: 52.7 KB
- Stars: 1
- Watchers: 1
- Forks: 0
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
Awesome Lists containing this project
README
# Range Sum of BST
## https://leetcode.com/problems/range-sum-of-bst
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:**
1. The number of nodes in the tree is at most 10000.
2. The final answer is guaranteed to be less than 2^31.
## Implementation : Considering the input as just Binary Tree
```java
/**
* Definition for a binary tree node.
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode() {}
* TreeNode(int val) { this.val = val; }
* TreeNode(int val, TreeNode left, TreeNode right) {
* this.val = val;
* this.left = left;
* this.right = right;
* }
* }
*/
class Solution {
public int rangeSumBST(TreeNode root, int low, int high) {
int[] result = new int[1];
rangeSum(root, low, high, result);
return result[0];
}
private void rangeSum(TreeNode node, int low, int high, int[] result) {
if(node.val >= low && node.val <= high)
result[0] += node.val;
if(node.left != null)
rangeSum(node.left, low, high, result);
if(node.right != null)
rangeSum(node.right, low, high, result);
}
}
```
## Implementation 2 : Utilizing the fact that we are given a BST, reducing the search space
```java
/**
* Definition for a binary tree node.
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode() {}
* TreeNode(int val) { this.val = val; }
* TreeNode(int val, TreeNode left, TreeNode right) {
* this.val = val;
* this.left = left;
* this.right = right;
* }
* }
*/
class Solution {
public int rangeSumBST(TreeNode root, int low, int high) {
int[] result = new int[1];
rangeSum(root, low, high, result);
return result[0];
}
private void rangeSum(TreeNode node, int low, int high, int[] result) {
if(node.val >= low && node.val <= high)
result[0] += node.val;
if(node.left != null && node.val > low)
rangeSum(node.left, low, high, result);
if(node.right != null && node.val < high)
rangeSum(node.right, low, high, result);
}
}
```
# References :
https://www.youtube.com/watch?v=SIdrJwWp3H0