refactor 536

Author: fishercoder1534

README.md

@@ -108,7 +108,7 @@ Your ideas/fixes/algorithms are more than welcome!
 |539|[Minimum Time Difference](https://leetcode.com/problems/minimum-time-difference/)|[Solution](../master/src/main/java/com/fishercoder/solutions/MinimumTimeDifference.java) | O(n) |O(1) | Medium | String
 |538|[Convert BST to Greater Tree](https://leetcode.com/problems/convert-bst-to-greater-tree/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_538.java) | O(n) |O(h) | Medium | Tree
 |537|[Complex Number Multiplication](https://leetcode.com/problems/complex-number-multiplication/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_537.java) | O(1) |O(1) | Medium | Math, String
-|536|[Construct Binary Tree from String](https://leetcode.com/problems/construct-binary-tree-from-string/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_536.java) | O(n) |O(h) | Medium | Recursion
+|536|[Construct Binary Tree from String](https://leetcode.com/problems/construct-binary-tree-from-string/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_536.java) | O(n) |O(h) | Medium | Recursion, Stack
 |535|[Encode and Decode TinyURL](https://leetcode.com/problems/encode-and-decode-tinyurl/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_535.java) | O(1) |O(n) | Medium | Design
 |533|[Lonely Pixel II](https://leetcode.com/problems/lonely-pixel-ii/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_533.java) | O(m*n) |O(m) (m is number of rows) | Medium | HashMap
 |532|[K-diff Pairs in an Array](https://leetcode.com/problems/k-diff-pairs-in-an-array/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_532.java) | O(n) |O(n) | Easy | HashMap

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

@@ -2,7 +2,12 @@
 
 import com.fishercoder.common.classes.TreeNode;
 
+import java.util.ArrayDeque;
+import java.util.Deque;
+
 /**
+ * 536. Construct Binary Tree from String
+ *
  * You need to construct a binary tree from a string consisting of parenthesis and integers.
  The whole input represents a binary tree. It contains an integer followed by zero, one or two pairs of parenthesis.
  The integer represents the root's value and a pair of parenthesis contains a child binary tree with the same structure.
@@ -22,27 +27,60 @@
  There will only be '(', ')', '-' and '0' ~ '9' in the input string.
  An empty tree is represented by "" instead of "()".
  */
+
 public class _536 {
 
-    public TreeNode str2tree(String s) {
-        if (s.equals("")) return null;
-        int firstParen = s.indexOf("(");
-        int val = firstParen == -1 ? Integer.parseInt(s) : Integer.parseInt(s.substring(0, firstParen));
-        TreeNode cur = new TreeNode(val);
-        if (firstParen == -1) return cur;
-        int start = firstParen;
-        int leftParenCount = 0;
-        for (int i = start; i < s.length(); i++) {
-            if (s.charAt(i) == '(') leftParenCount++;
-            else if (s.charAt(i) == ')') leftParenCount--;
-            if (leftParenCount == 0 && start == firstParen) {
-                cur.left = str2tree(s.substring(start + 1, i));
-                start = i + 1;
-            } else if (leftParenCount == 0) {
-                cur.right = str2tree(s.substring(start + 1, i));
+    public static class Solution1 {
+        public TreeNode str2tree(String s) {
+            if (s.equals("")) return null;
+            int firstParen = s.indexOf("(");
+            int val = firstParen == -1 ? Integer.parseInt(s) : Integer.parseInt(s.substring(0, firstParen));
+            TreeNode cur = new TreeNode(val);
+            if (firstParen == -1) return cur;
+            int start = firstParen;
+            int leftParenCount = 0;
+            for (int i = start; i < s.length(); i++) {
+                if (s.charAt(i) == '(') {
+                    leftParenCount++;
+                } else if (s.charAt(i) == ')') {
+                    leftParenCount--;
+                }
+                if (leftParenCount == 0 && start == firstParen) {
+                    cur.left = str2tree(s.substring(start + 1, i));
+                    start = i + 1;
+                } else if (leftParenCount == 0) {
+                    cur.right = str2tree(s.substring(start + 1, i));
+                }
+            }
+            return cur;
+        }
+    }
+
+    public static class Solution2 {
+        public TreeNode str2tree(String s) {
+            Deque<TreeNode> stack = new ArrayDeque<>();
+            for (int i = 0, j = i; i < s.length(); i++, j = i) {
+                char c = s.charAt(i);
+                if (c == ')') {
+                    stack.pop();
+                } else if (c >= '0' && c <= '9' || c == '-') {
+                    while (i + 1 < s.length() && s.charAt(i + 1) >= '0' && s.charAt(i + 1) <= '9') {
+                        i++;
+                    }
+                    TreeNode curr = new TreeNode(Integer.valueOf(s.substring(j, i + 1)));
+                    if (!stack.isEmpty()) {
+                        TreeNode parent = stack.peek();
+                        if (parent.left != null) {
+                            parent.right = curr;
+                        } else {
+                            parent.left = curr;
+                        }
+                    }
+                    stack.push(curr);
+                }
             }
+            return stack.isEmpty() ? null : stack.peek();
         }
-        return cur;
     }
 
 }

src/test/java/com/fishercoder/_536Test.java

@@ -9,14 +9,16 @@
 import static junit.framework.Assert.assertEquals;
 
 public class _536Test {
-    private static _536 test;
+    private static _536.Solution1 solution1;
+    private static _536.Solution2 solution2;
     private static TreeNode expected;
     private static TreeNode actual;
     private static String s;
 
     @BeforeClass
     public static void setup(){
-        test = new _536();
+        solution1 = new _536.Solution1();
+        solution2 = new _536.Solution2();
     }
 
     @Before
@@ -30,8 +32,10 @@ public void setupForEachTest(){
     public void test1(){
         s = "";
         expected = null;
-        actual = test.str2tree(s);
+        actual = solution1.str2tree(s);
         assertEquals(expected, actual);
 
+        actual = solution2.str2tree(s);
+        assertEquals(expected, actual);
     }
 }