add 1008

Author: fishercoder1534

README.md

@@ -42,6 +42,7 @@ Your ideas/fixes/algorithms are more than welcome!
 |1011|[Capacity To Ship Packages Within D Days](https://leetcode.com/problems/capacity-to-ship-packages-within-d-days/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_1011.java) | O(nlogn) | O(1) | |Medium|Binary Search|
 |1010|[Pairs of Songs With Total Durations Divisible by 60](https://leetcode.com/problems/pairs-of-songs-with-total-durations-divisible-by-60/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_1010.java) | O(n) | O(1) | |Easy|
 |1009|[Complement of Base 10 Integer](https://leetcode.com/problems/complement-of-base-10-integer/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_1009.java) | O(n) | O(1) | |Easy|
+|1008|[Construct Binary Search Tree from Preorder Traversal](https://leetcode.com/problems/construct-binary-search-tree-from-preorder-traversal/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_1008.java) | O(n) | O(1) | |Medium| Recursion
 |1003|[Check If Word Is Valid After Substitutions](https://leetcode.com/problems/check-if-word-is-valid-after-substitutions/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_1003.java) | O(n) | O(n) | |Medium|
 |1002|[Find Common Characters](https://leetcode.com/problems/find-common-characters/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_1002.java) | O(n) | O(1) | |Easy|
 |999|[Available Captures for Rook](https://leetcode.com/problems/available-captures-for-rook/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_999.java) | O(1) | O(1) | |Easy|

src/main/java/com/fishercoder/solutions/_1008.java

@@ -0,0 +1,47 @@
+package com.fishercoder.solutions;
+
+import com.fishercoder.common.classes.TreeNode;
+
+/**
+ * 1008. Construct Binary Search Tree from Preorder Traversal
+ *
+ * Return the root node of a binary search tree that matches the given preorder traversal.
+ * (Recall that a binary search tree is a binary tree where for every node, any descendant of node.left has a value < node.val, and any descendant of node.right has a value > node.val.  Also recall that a preorder traversal displays the value of the node first, then traverses node.left, then traverses node.right.)
+ *
+ *
+ * Example 1:
+ *
+ * Input: [8,5,1,7,10,12]
+ * Output: [8,5,10,1,7,null,12]
+ *
+ *              8
+ *             / \
+ *            5  10
+ *           / \   \
+ *          1   7  12
+ *
+ * Note:
+ *
+ * 1 <= preorder.length <= 100
+ * The values of preorder are distinct.
+ * */
+public class _1008 {
+    public static class Solution1 {
+        /**credit: https://leetcode.com/problems/construct-binary-search-tree-from-preorder-traversal/discuss/252232/JavaC%2B%2BPython-O(N)-Solution*/
+        int i = 0;
+
+        public TreeNode bstFromPreorder(int[] preorder) {
+            return bstFromPreorder(preorder, Integer.MAX_VALUE);
+        }
+
+        private TreeNode bstFromPreorder(int[] preorder, int bound) {
+            if (i == preorder.length || preorder[i] > bound) {
+                return null;
+            }
+            TreeNode root = new TreeNode(preorder[i++]);
+            root.left = bstFromPreorder(preorder, root.val);
+            root.right = bstFromPreorder(preorder, bound);
+            return root;
+        }
+    }
+}

src/test/java/com/fishercoder/_1008Test.java

@@ -0,0 +1,29 @@
+package com.fishercoder;
+
+import com.fishercoder.common.classes.TreeNode;
+import com.fishercoder.common.utils.TreeUtils;
+import com.fishercoder.solutions._1008;
+import org.junit.Test;
+
+import java.util.Arrays;
+
+import static junit.framework.Assert.assertEquals;
+
+public class _1008Test {
+    private static _1008.Solution1 solution1;
+    private static int[] preorder;
+    private static TreeNode expected;
+    private static TreeNode actual;
+
+    @Test
+    public void test1() {
+        solution1 = new _1008.Solution1();
+        preorder = new int[]{8, 5, 1, 7, 10, 12};
+        expected = TreeUtils.constructBinaryTree(Arrays.asList(8, 5, 10, 1, 7, null, 12));
+        TreeUtils.printBinaryTree(expected);
+        actual = solution1.bstFromPreorder(preorder);
+        TreeUtils.printBinaryTree(actual);
+        assertEquals(expected, actual);
+    }
+
+}