add 938

fishercoder1534 · fishercoder1534 · commit 59dfda641591 · 2019-01-01T20:48:03.000-08:00
diff --git a/README.md b/README.md
@@ -34,6 +34,7 @@ Your ideas/fixes/algorithms are more than welcome!
 |953|[Verifying an Alien Dictionary](https://leetcode.com/problems/verifying-an-alien-dictionary/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_953.java) | O(1) | O(1) | |Easy|
 |944|[Delete Columns to Make Sorted](https://leetcode.com/problems/delete-columns-to-make-sorted/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_944.java) | O(n) | O(1) | |Easy|
 |941|[Valid Mountain Array](https://leetcode.com/problems/valid-mountain-array/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_941.java) | O(n) | O(1) | |Easy|
+|938|[Range Sum of BST](https://leetcode.com/problems/range-sum-of-bst/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_938.java) | O(n) | O(n) | |Medium| BST, recursion, DFS
 |933|[Number of Recent Calls](https://leetcode.com/problems/number-of-recent-calls/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_933.java) | O(n) | O(n) | |Easy|
 |929|[Unique Email Addresses](https://leetcode.com/problems/unique-email-addresses/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_929.java) | O(n) | O(n) | |Easy|
 |925|[Long Pressed Name](https://leetcode.com/problems/long-pressed-name/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_925.java) | O(n) | O(1) | |Easy|
diff --git a/src/main/java/com/fishercoder/solutions/_938.java b/src/main/java/com/fishercoder/solutions/_938.java
@@ -0,0 +1,52 @@
+package com.fishercoder.solutions;
+
+import com.fishercoder.common.classes.TreeNode;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * 938. 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:
+ *
+ * The number of nodes in the tree is at most 10000.
+ * The final answer is guaranteed to be less than 2^31.
+ */
+public class _938 {
+  public static class Solution1 {
+    public int rangeSumBST(TreeNode root, int L, int R) {
+      if (root == null) {
+        return 0;
+      }
+      List<Integer> list = new ArrayList<>();
+      dfs(root, L, R, list);
+      return list.stream().mapToInt(num -> num).sum();
+    }
+
+    private void dfs(TreeNode root, int l, int r, List<Integer> list) {
+      if (root == null) {
+        return;
+      }
+      if (root.val <= r && root.val >= l) {
+        list.add(root.val);
+      }
+      dfs(root.left, l, r, list);
+      dfs(root.right, l, r, list);
+    }
+  }
+}
diff --git a/src/test/java/com/fishercoder/_938Test.java b/src/test/java/com/fishercoder/_938Test.java
@@ -0,0 +1,34 @@
+package com.fishercoder;
+
+import com.fishercoder.common.classes.TreeNode;
+import com.fishercoder.common.utils.TreeUtils;
+import com.fishercoder.solutions._938;
+import java.util.Arrays;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+public class _938Test {
+  private static _938.Solution1 solution1;
+  private static TreeNode root;
+
+  @BeforeClass
+  public static void setup() {
+    solution1 = new _938.Solution1();
+  }
+
+  @Test
+  public void test1() {
+    root = TreeUtils.constructBinaryTree(Arrays.asList(10, 5, 15, 3, 7, null, 18));
+    TreeUtils.printBinaryTree(root);
+    assertEquals(32, solution1.rangeSumBST(root, 7, 15));
+  }
+
+  @Test
+  public void test2() {
+    root = TreeUtils.constructBinaryTree(Arrays.asList(10, 5, 15, 3, 7, 13, 18, 1, null, 6));
+    TreeUtils.printBinaryTree(root);
+    assertEquals(23, solution1.rangeSumBST(root, 6, 10));
+  }
+}
