refactor 105

fishercoder1534 · fishercoder1534 · commit d15b61817315 · 2018-03-19T07:33:11.000-07:00
diff --git a/src/main/java/com/fishercoder/solutions/_105.java b/src/main/java/com/fishercoder/solutions/_105.java
@@ -14,40 +14,42 @@
  */
 public class _105 {
 
-	/**
-	 * credit: https://discuss.leetcode.com/topic/29838/5ms-java-clean-solution-with-caching
-	 * use HashMap as the cache so that accessing inorder index becomes O(1) time
-	 * Note: The first element of preorder array is the root!
-	 */
-	public TreeNode buildTree(int[] preorder, int[] inorder) {
-		Map<Integer, Integer> inorderMap = new HashMap();
-		for (int i = 0; i < inorder.length; i++) {
-			inorderMap.put(inorder[i], i);
+	public static class Solution1 {
+		/**
+		 * credit: https://discuss.leetcode.com/topic/29838/5ms-java-clean-solution-with-caching use
+		 * HashMap as the cache so that accessing inorder index becomes O(1) time Note: The first
+		 * element of preorder array is the root!
+		 */
+		public TreeNode buildTree(int[] preorder, int[] inorder) {
+			Map<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 buildTree(preorder, 0, preorder.length - 1, inorderMap, 0, inorder.length - 1);
 		}
 
-		/**At the beginning, both start from 0 to nums.length-1*/
-		return buildTree(preorder, 0, preorder.length - 1, inorderMap, 0, inorder.length - 1);
-	}
-
-	private TreeNode buildTree(int[] preorder, int preStart, int preEnd, Map<Integer, Integer> inorderMap, int inStart, int inEnd) {
-		if (preStart > preEnd || inStart > inEnd) {
-			return null;
+		private TreeNode buildTree(int[] preorder, int preStart, int preEnd,
+				Map<Integer, Integer> inorderMap, int inStart, int inEnd) {
+			if (preStart > preEnd || inStart > inEnd) {
+				return null;
+			}
+
+			TreeNode root = new TreeNode(preorder[preStart]);
+			int inRoot = inorderMap.get(preorder[preStart]);
+			int numsLeft = inRoot - inStart;
+
+			/**It's easy to understand and remember:
+			 * for the indices of inorder array:
+			 * root.left should be inStart and inRoot-1 as new start and end indices
+			 * root.right should be inRoot+1 and inEnd as new start and end indices
+			 *
+			 * since inRoot is being used already in this recursion call, that's why we use inRoot-1 and inRoot+1
+			 * this part is the same for both Leetcode 105 and Leetcode 106.*/
+			root.left = buildTree(preorder, preStart + 1, preStart + numsLeft, inorderMap, inStart, inRoot - 1);
+			root.right = buildTree(preorder, preStart + numsLeft + 1, preEnd, inorderMap, inRoot + 1, inEnd);
+			return root;
 		}
-
-		TreeNode root = new TreeNode(preorder[preStart]);
-		int inRoot = inorderMap.get(preorder[preStart]);
-		int numsLeft = inRoot - inStart;
-
-		/**It's easy to understand and remember:
-		 * for the indices of inorder array:
-		 * root.left should be inStart and inRoot-1 as new start and end indices
-		 * root.right should be inRoot+1 and inEnd as new start and end indices
-		 *
-		 * since inRoot is being used already in this recursion call, that's why we use inRoot-1 and inRoot+1
-		 * this part is the same for both Leetcode 105 and Leetcode 106.*/
-		root.left = buildTree(preorder, preStart + 1, preStart + numsLeft, inorderMap, inStart, inRoot - 1);
-		root.right = buildTree(preorder, preStart + numsLeft + 1, preEnd, inorderMap, inRoot + 1, inEnd);
-		return root;
 	}
-
 }
diff --git a/src/test/java/com/fishercoder/_105Test.java b/src/test/java/com/fishercoder/_105Test.java
@@ -1,48 +1,41 @@
 package com.fishercoder;
 
 import com.fishercoder.common.classes.TreeNode;
+import com.fishercoder.common.utils.TreeUtils;
 import com.fishercoder.solutions._105;
+import java.util.Arrays;
 import org.junit.BeforeClass;
 import org.junit.Test;
 
 import static junit.framework.Assert.assertEquals;
 
-/**
- * Created by fishercoder on 5/1/17.
- */
 public class _105Test {
-    private static _105 test;
-    private static TreeNode expected;
-    private static TreeNode actual;
-    private static int[] preorder;
-    private static int[] inorder;
+  private static _105.Solution1 solution1;
+  private static TreeNode expected;
+  private static TreeNode actual;
+  private static int[] preorder;
+  private static int[] inorder;
 
-    @BeforeClass
-    public static void setup() {
-        test = new _105();
-    }
+  @BeforeClass
+  public static void setup() {
+    solution1 = new _105.Solution1();
+  }
 
-    @Test
-    public void test1() {
-        preorder = new int[]{1, 2, 3};
-        inorder = new int[]{2, 1, 3};
-        actual = test.buildTree(preorder, inorder);
-        expected = new TreeNode(1);
-        expected.left = new TreeNode(2);
-        expected.right = new TreeNode(3);
-        assertEquals(expected, actual);
-    }
+  @Test
+  public void test1() {
+    preorder = new int[] {1, 2, 3};
+    inorder = new int[] {2, 1, 3};
+    actual = solution1.buildTree(preorder, inorder);
+    expected = TreeUtils.constructBinaryTree(Arrays.asList(1, 2, 3));
+    assertEquals(expected, actual);
+  }
 
-    @Test
-    public void test2() {
-        preorder = new int[]{1, 2, 4, 5, 3};
-        inorder = new int[]{4, 2, 5, 1, 3};
-        actual = test.buildTree(preorder, inorder);
-        expected = new TreeNode(1);
-        expected.left = new TreeNode(2);
-        expected.right = new TreeNode(3);
-        expected.left.left = new TreeNode(4);
-        expected.left.right = new TreeNode(5);
-        assertEquals(expected, actual);
-    }
+  @Test
+  public void test2() {
+    preorder = new int[] {1, 2, 4, 5, 3};
+    inorder = new int[] {4, 2, 5, 1, 3};
+    actual = solution1.buildTree(preorder, inorder);
+    expected = TreeUtils.constructBinaryTree(Arrays.asList(1, 2, 3, 4, 5));
+    assertEquals(expected, actual);
+  }
 }
