add 776

fishercoder1534 · fishercoder1534 · commit 0c1d807a77ea · 2018-02-05T07:46:48.000-08:00
diff --git a/README.md b/README.md
@@ -23,6 +23,7 @@ Your ideas/fixes/algorithms are more than welcome!
 |  #  |      Title     |   Solutions   | Time          | Space         | Video  | Difficulty  | Tag                   
 |-----|----------------|---------------|---------------|---------------|--------|-------------|-------------
 |779|[K-th Symbol in Grammar](https://leetcode.com/problems/k-th-symbol-in-grammar/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_779.java) | O(logn) | O(1) | |Medium|
+|776|[Split BST](https://leetcode.com/problems/split-bst/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_776.java) | O(n) | O(n) | |Medium| Recursion
 |771|[Jewels and Stones](https://leetcode.com/problems/jewels-and-stones/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_771.java) | O(n) | O(m) | |Easy|
 |767|[Reorganize String](https://leetcode.com/problems/reorganize-string/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_767.java) | O(klogk) k is the number of unique characters in given String| O(k) | |Medium|
 |766|[Toeplitz Matrix](https://leetcode.com/problems/toeplitz-matrix/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_766.java) | O(m*n) | O(1) | |Easy|
diff --git a/src/main/java/com/fishercoder/solutions/_776.java b/src/main/java/com/fishercoder/solutions/_776.java
@@ -0,0 +1,93 @@
+package com.fishercoder.solutions;
+
+import com.fishercoder.common.classes.TreeNode;
+
+/**
+ * 776. Split BST
+ *
+ * Given a Binary Search Tree (BST) with root node root, and a target value V,
+ * split the tree into two subtrees where one subtree has nodes that are all smaller or equal to the target value,
+ * while the other subtree has all nodes that are greater than the target value.
+ * It's not necessarily the case that the tree contains a node with value V.
+ * Additionally, most of the structure of the original tree should remain.
+ * Formally, for any child C with parent P in the original tree,
+ * if they are both in the same subtree after the split, then node C should still have the parent P.
+ * You should output the root TreeNode of both subtrees after splitting, in any order.
+
+ Example 1:
+
+ Input: root = [4,2,6,1,3,5,7], V = 2
+ Output: [[2,1],[4,3,6,null,null,5,7]]
+
+ Explanation:
+ Note that root, output[0], and output[1] are TreeNode objects, not arrays.
+
+ The given tree [4,2,6,1,3,5,7] is represented by the following diagram:
+
+       4
+    /     \
+   2      6
+  /  \   / \
+ 1   3  5   7
+
+ while the diagrams for the outputs are:
+
+   4
+ /   \
+3     6      and    2
+     / \           /
+    5   7         1
+
+ Note:
+
+ The size of the BST will not exceed 50.
+ The BST is always valid and each node's value is different.
+ */
+
+public class _776 {
+  public static class Solution1 {
+    /** credit: https://discuss.leetcode.com/topic/119481/recursive-java-solution */
+    public TreeNode[] splitBST(TreeNode root, int V) {
+      TreeNode small = new TreeNode(0);
+      TreeNode big = new TreeNode(0);
+      split(root, V, small, big);
+      return new TreeNode[] {small.right, big.left};
+    }
+
+    private void split(TreeNode root, int v, TreeNode small, TreeNode big) {
+      if (root == null) {
+        return;
+      }
+      if (root.val <= v) {
+        small.right = root;
+        TreeNode right = root.right;
+        root.right = null;
+        split(right, v, root, big);
+      } else {
+        big.left = root;
+        TreeNode left = root.left;
+        root.left = null;
+        split(left, v, small, root);
+      }
+    }
+  }
+
+  public static class Solution2 {
+    /** credit: https://leetcode.com/articles/split-bst/ */
+    public TreeNode[] splitBST(TreeNode root, int V) {
+      if (root == null) {
+        return new TreeNode[] {null, null};
+      } else if (root.val <= V) {
+        TreeNode[] result = splitBST(root.right, V);
+        root.right = result[0];
+        result[0] = root;
+        return result;
+      } else {
+        TreeNode[] result = splitBST(root.left, V);
+        root.left = result[1];
+        result[1] = root;
+        return result;
+      }
+    }
+  }
+}
diff --git a/src/test/java/com/fishercoder/_776Test.java b/src/test/java/com/fishercoder/_776Test.java
@@ -0,0 +1,40 @@
+package com.fishercoder;
+
+import com.fishercoder.common.classes.TreeNode;
+import com.fishercoder.common.utils.TreeUtils;
+import com.fishercoder.solutions._776;
+import java.util.Arrays;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import static org.junit.Assert.assertArrayEquals;
+
+public class _776Test {
+  private static _776.Solution1 solution1;
+  private static _776.Solution2 solution2;
+  private static TreeNode root;
+  private static TreeNode small;
+  private static TreeNode big;
+
+  @BeforeClass
+  public static void setup() {
+    solution1 = new _776.Solution1();
+    solution2 = new _776.Solution2();
+  }
+
+  @Test
+  public void test1() {
+    root = TreeUtils.constructBinaryTree(Arrays.asList(4, 2, 6, 1, 3, 5, 7));
+    small = TreeUtils.constructBinaryTree(Arrays.asList(2, 1));
+    big = TreeUtils.constructBinaryTree(Arrays.asList(4, 3, 6, null, null, 5, 7));
+    assertArrayEquals(new TreeNode[] {small, big}, solution1.splitBST(root, 2));
+  }
+
+  @Test
+  public void test2() {
+    root = TreeUtils.constructBinaryTree(Arrays.asList(4, 2, 6, 1, 3, 5, 7));
+    small = TreeUtils.constructBinaryTree(Arrays.asList(2, 1));
+    big = TreeUtils.constructBinaryTree(Arrays.asList(4, 3, 6, null, null, 5, 7));
+    assertArrayEquals(new TreeNode[] {small, big}, solution2.splitBST(root, 2));
+  }
+}
