refactor 106

Author: fishercoder1534

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

@@ -12,56 +12,58 @@
 
  Note:
  You may assume that duplicates do not exist in the tree.
-
  */
 public class _106 {
+    public static class Solution1 {
 
-    /**
-     * https://discuss.leetcode.com/topic/3296/my-recursive-java-code-with-o-n-time-and-o-n-space
-     *
-     * Note: the last element of postorder array is the root!
-     *
-     * The idea is to take the last element in postorder as the root; find the position of the root in the inorder array;
-     * then locate the range for left sub-tree and right sub-tree and do recursion,
-     * use a hashmap to record the index of root in the inorder array.
-     */
-    public TreeNode buildTree(int[] inorder, int[] postorder) {
-        if (inorder == null || postorder == null || inorder.length != postorder.length) {
-            return null;
-        }
-        HashMap<Integer, Integer> inorderMap = new HashMap<>();
-        for (int i = 0; i < inorder.length; i++) {
-            inorderMap.put(inorder[i], i);
+        /**
+         * https://discuss.leetcode.com/topic/3296/my-recursive-java-code-with-o-n-time-and-o-n-space
+         *
+         * Note: the last element of postorder array is the root!
+         *
+         * The idea is to take the last element in postorder as the root; find the position of the root
+         * in the inorder array; then locate the range for left sub-tree and right sub-tree and do
+         * recursion, use a hashmap to record the index of root in the inorder array.
+         */
+        public TreeNode buildTree(int[] inorder, int[] postorder) {
+            if (inorder == null || postorder == null || inorder.length != postorder.length) {
+                return null;
+            }
+            HashMap<Integer, Integer> inorderMap = new HashMap<>();
+            for (int i = 0; i < inorder.length; i++) {
+                inorderMap.put(inorder[i], i);
+            }
+            /**At the beginning, both start from 0 to nums.length-1*/
+            return buildTreeRecursively(inorderMap, 0, inorder.length - 1, postorder, 0,
+                postorder.length - 1);
         }
-        /**At the beginning, both start from 0 to nums.length-1*/
-        return buildTreeRecursively(inorderMap, 0, inorder.length - 1, postorder, 0, postorder.length - 1);
-    }
 
-    private TreeNode buildTreeRecursively(Map<Integer, Integer> inorderMap, int inorderStart, int inorderEnd, int[] postorder, int postorderStart, int postorderEnd) {
-        if (postorderStart > postorderEnd || inorderStart > inorderEnd) {
-            return null;
-        }
-        TreeNode root = new TreeNode(postorder[postorderEnd]);
-        int inRoot = inorderMap.get(postorder[postorderEnd]);
-        int numsLeft = inRoot - inorderStart;
+        private TreeNode buildTreeRecursively(Map<Integer, Integer> inorderMap, int inorderStart,
+            int inorderEnd, int[] postorder, int postorderStart, int postorderEnd) {
+            if (postorderStart > postorderEnd || inorderStart > inorderEnd) {
+                return null;
+            }
+            TreeNode root = new TreeNode(postorder[postorderEnd]);
+            int inRoot = inorderMap.get(postorder[postorderEnd]);
+            int numsLeft = inRoot - inorderStart;
 
-        /**It's easy to understand and remember:
-         * for the indices of inorder array:
-         * inStart and inRoot-1 as new start and end indices
-         * inRoot+1 and inEnd as new start and end indices
-         *
-         * this is easy to understand and remember: since inRoot is already been used in this recursion call, so we're going to use inRoot-1 and inRoot+1 for next recursion call
-         *
-         * for the indices of postorder array:
-         * postorderStart and postorderStart+numsLeft-1 should be the new start and end indices
-         * postorderStart+numsLeft and postorderEnd-1 should be the new start and end indices
-         *
-         * this is also easy to understand and remember:
-         * since the last one in postorder is the root and we have used it in this recursion call already, so the end is definitely postorderEnd-1;
-         * then the postorderEnd for root.left is contiguous to the postorderStart of root.right, :)*/
-        root.left = buildTreeRecursively(inorderMap, inorderStart, inRoot - 1, postorder, postorderStart, postorderStart + numsLeft - 1);
-        root.right = buildTreeRecursively(inorderMap, inRoot + 1, inorderEnd, postorder, postorderStart + numsLeft, postorderEnd - 1);
-        return root;
+            /**It's easy to understand and remember:
+             * for the indices of inorder array:
+             * inStart and inRoot-1 as new start and end indices
+             * inRoot+1 and inEnd as new start and end indices
+             *
+             * this is easy to understand and remember: since inRoot is already been used in this recursion call, so we're going to use inRoot-1 and inRoot+1 for next recursion call
+             *
+             * for the indices of postorder array:
+             * postorderStart and postorderStart+numsLeft-1 should be the new start and end indices
+             * postorderStart+numsLeft and postorderEnd-1 should be the new start and end indices
+             *
+             * this is also easy to understand and remember:
+             * since the last one in postorder is the root and we have used it in this recursion call already, so the end is definitely postorderEnd-1;
+             * then the postorderEnd for root.left is contiguous to the postorderStart of root.right, :)*/
+            root.left = buildTreeRecursively(inorderMap, inorderStart, inRoot - 1, postorder, postorderStart, postorderStart + numsLeft - 1);
+            root.right = buildTreeRecursively(inorderMap, inRoot + 1, inorderEnd, postorder, postorderStart + numsLeft, postorderEnd - 1);
+            return root;
+        }
     }
-
 }

src/test/java/com/fishercoder/_106Test.java

@@ -10,19 +10,16 @@
 
 import static junit.framework.Assert.assertEquals;
 
-/**
- * Created by fishercoder on 5/12/17.
- */
 public class _106Test {
-    private static _106 test;
+    private static _106.Solution1 solution1;
     private static TreeNode expected;
     private static TreeNode actual;
     private static int[] inorder;
     private static int[] postorder;
 
     @BeforeClass
     public static void setup() {
-        test = new _106();
+        solution1 = new _106.Solution1();
     }
 
     @Test
@@ -36,7 +33,7 @@ public void test1() {
          */
         postorder = new int[]{2, 1, 3};
         inorder = new int[]{1, 2, 3};
-        actual = test.buildTree(inorder, postorder);
+        actual = solution1.buildTree(inorder, postorder);
         expected = TreeUtils.constructBinaryTree(Arrays.asList(3, 1, null, null, 2));
         assertEquals(expected, actual);
     }
@@ -56,7 +53,7 @@ public void test2() {
          */
         postorder = new int[]{4, 2, 5, 1, 3};
         inorder  = new int[]{1, 2, 4, 5, 3};
-        actual = test.buildTree(inorder, postorder);
+        actual = solution1.buildTree(inorder, postorder);
         expected = TreeUtils.constructBinaryTree(Arrays.asList(3, 1, null, null, 5, 2, null, null, 4));
         assertEquals(expected, actual);
     }
@@ -70,7 +67,7 @@ public void test3() {
          */
         inorder = new int[]{1, 2};
         postorder = new int[]{1, 2};
-        actual = test.buildTree(inorder, postorder);
+        actual = solution1.buildTree(inorder, postorder);
         expected = TreeUtils.constructBinaryTree(Arrays.asList(2, 1));
         assertEquals(expected, actual);
     }