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.定义二叉树结构。
2.通过数组创建二叉树以便测试。
3.编写区间求和方法(两种情况,
①如根节点值在区间内,则加上根节点值,左右节点继续判断是否在区间内然后递归求和;
②如根节点不在区间内,则直接左右节点继续判断是否在区间内然后递归求和
)。
package test;
class Solution {
/**
* 1. 定义二叉树结构
*/
class TreeNode {
int val;
TreeNode left;
TreeNode right;
TreeNode(int x) {
val = x;
}
}
/**
* 2. 数组转化为完全二叉树结构
*
* @param array 数组
* @param index 下标
* @return
*/
TreeNode createBinaryTreeByArray(Integer[] array, int index) {
TreeNode tree = null;
if (index < array.length) {
Integer value = array[index];
if (value == null) return null;
tree = new TreeNode(value);
tree.left = createBinaryTreeByArray(array, 2 * index + 1);
tree.right = createBinaryTreeByArray(array, 2 * index + 2);
}
return tree;
}
/**
* 3. 二叉树区间求和
* @param root 二叉树根节点
* @param L 左区间 (包含)
* @param R 右区间 (包含)
* @return 区间和
*/
public int rangeSumBST(TreeNode root, int L, int R) {
if (root == null) {
return 0;
}
// 如根节点值在区间内,则加上根节点值,左右节点继续判断是否在区间内然后递归求和
if (root.val >= L && root.val <= R) {
return root.val + rangeSumBST(root.left, L, R) + rangeSumBST(root.right, L, R);
}
// 如根节点不在区间内,则直接左右节点继续判断是否在区间内然后递归求和
return rangeSumBST(root.left, L, R) + rangeSumBST(root.right, L, R);
}
public static void main(String[] args){
Integer[] datas = new Integer[]{10,5,15,3,7,13,18,1,null,6};
Solution solution = new Solution();
TreeNode root = solution.createBinaryTreeByArray(datas, 0);
System.out.println(solution.rangeSumBST(root, 7, 15));
}
}
参考一下一些大牛在discuss中的解法,可以 reduce the nodes we need to travel~
public int rangeSumBST(TreeNode root, int L, int R) {
if (root == null)
return 0;
int sum = 0;
if (root.val < L)
sum += rangeSumBST(root.right, L, R);
if (root.val > R)
sum += rangeSumBST(root.left, L, R);
if (root.val >= L && root.val <= R) {
sum += root.val;
if (root.val == L)
sum += rangeSumBST(root.right, L, R);
else if (root.val == R)
sum += rangeSumBST(root.left, L, R);
else {
sum += rangeSumBST(root.right, L, R);
sum += rangeSumBST(root.left, L, R);
}
}
return sum;
}
顺便温习了一下二叉树的四种遍历方法
①前序遍历(先根节点再左最后右)
②中序遍历(先左节点再根最后右)
③后序遍历(先左节点再右最后根)
④层次遍历 (一层一层节点遍历)
package test;
import java.util.LinkedList;
class Solution {
/**
* 1. 定义二叉树结构
*/
class TreeNode {
int val;
TreeNode left;
TreeNode right;
TreeNode(int x) {
val = x;
}
}
/**
* 2. 数组转化为完全二叉树结构
*
* @param array 数组
* @param index 下标
* @return
*/
TreeNode createBinaryTreeByArray(int index, Integer... array) {
TreeNode tree = null;
if (index < array.length) {
Integer value = array[index];
if (value == null) return null;
tree = new TreeNode(value);
tree.left = createBinaryTreeByArray(2 * index + 1, array);
tree.right = createBinaryTreeByArray(2 * index + 2, array);
}
return tree;
}
/**
* 3. 二叉树区间求和
* @param root 二叉树根节点
* @param L 左区间 (包含)
* @param R 右区间 (包含)
* @return 区间和
*/
public int rangeSumBST(TreeNode root, int L, int R) {
if (root == null) {
return 0;
}
// 如根节点值在区间内,则加上根节点值,左右节点继续判断是否在区间内然后递归求和
if (root.val >= L && root.val <= R) {
return root.val + rangeSumBST(root.left, L, R) + rangeSumBST(root.right, L, R);
}
// 如根节点不在区间内,则直接左右节点继续判断是否在区间内然后递归求和
return rangeSumBST(root.left, L, R) + rangeSumBST(root.right, L, R);
}
//前序遍历
public void preorder(TreeNode root) {
if (root == null) return;
System.out.println(root.val);
preorder(root.left);
preorder(root.right);
}
//中序遍历
public void inorder(TreeNode root){
if (root == null) return;
inorder(root.left);
System.out.println(root.val);
inorder(root.right);
}
// 后序遍历
public void postorder(TreeNode root){
if (root == null) return;
postorder(root.left);
postorder(root.right);
System.out.println(root.val);
}
/**
* 层次遍历和其他三种遍历不一样,需要借助队列来实现
* @param root
*/
public void storeyTraversal(TreeNode root){
if (root == null) {
return;
}
LinkedList<TreeNode> list = new LinkedList<TreeNode>();
list.add(root); // 先将根节点放进list
while (!list.isEmpty()) {
TreeNode currentNode = list.poll(); // 每次取出并移除list首元素
if (currentNode != null) {
System.out.println(currentNode.val);
if (currentNode.left != null) {
list.add(currentNode.left);
}
if (currentNode.right != null) {
list.add(currentNode.right);
}
}
}
}
public static void main(String[] args){
Integer[] datas = new Integer[]{10,5,15,3,7,13,18,1,null,6};
Solution solution = new Solution();
TreeNode root = solution.createBinaryTreeByArray(0, datas);
// System.out.println(solution.rangeSumBST(root, 6, 10));
// solution.preorder(root);
// solution.inorder(root);
// solution.postorder(root);
solution.storeyTraversal(root);
}
}