Signed-off-by: yuduozhou <[email protected]>

Author: yuduozhou

BSTIsBalanced.java

@@ -0,0 +1,23 @@
+/**
+ * Definition for binary tree
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode(int x) { val = x; }
+ * }
+ */
+public class Solution {
+    public boolean isBalanced(TreeNode root) {
+        // Start typing your Java solution below
+        // DO NOT write main() function
+        if (root == null) return true;
+        return (Math.abs(getMaxHeight(root.left)  - getMaxHeight(root.right)) <= 1) &&
+            isBalanced(root.left) && isBalanced(root.right);
+    }
+    
+    public int getMaxHeight(TreeNode root){
+        if (root == null) return 0;
+        return Math.max(getMaxHeight(root.left), getMaxHeight(root.right)) + 1;
+    }
+}

BSTLevelOrderTraversal_II.java

@@ -0,0 +1,38 @@
+/**
+ * Definition for binary tree
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode(int x) { val = x; }
+ * }
+ */
+public class Solution {
+    public ArrayList<ArrayList<Integer>> levelOrderBottom(TreeNode root) {
+        // Start typing your Java solution below
+        // DO NOT write main() function
+        ArrayList<ArrayList<Integer>> result = new ArrayList<ArrayList<Integer>>();
+        if (root == null) return result;
+        Stack<ArrayList<Integer>> aStack = new Stack<ArrayList<Integer>>();
+        Queue<TreeNode> nodeQ = new LinkedList<TreeNode>();
+        TreeNode dummy = new TreeNode(0);
+        nodeQ.add(root);
+        nodeQ.add(dummy);
+        while(nodeQ.size() > 0){
+            ArrayList<Integer> level = new ArrayList<Integer>();
+            while(nodeQ.peek() != dummy){
+                TreeNode temp = nodeQ.poll();
+                level.add(temp.val);
+                if (temp.left != null) nodeQ.add(temp.left);
+                if (temp.right != null) nodeQ.add(temp.right);
+            }
+            aStack.add(level);
+            if (nodeQ.size() == 1 && nodeQ.peek() == dummy) break;
+            nodeQ.add(nodeQ.poll());
+        }
+        while(!aStack.empty()){
+            result.add(aStack.pop());
+        }
+        return result;
+    }
+}

ConvertSortedArrayToBST.java

@@ -0,0 +1,29 @@
+/**
+ * Definition for binary tree
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode(int x) { val = x; }
+ * }
+ */
+public class Solution {
+    public TreeNode sortedArrayToBST(int[] num) {
+        // Start typing your Java solution below
+        // DO NOT write main() function
+        if (num == null || num.length == 0) return null;
+        return sortedArrayToBST(num, 0, num.length - 1);
+        
+    }
+    public TreeNode sortedArrayToBST(int[] num, int start, int end) {
+        // Start typing your Java solution below
+        // DO NOT write main() function
+        if (start == end) return new TreeNode(num[start]);
+        if (start > end) return null;
+        int mid = (start + end) / 2;
+        TreeNode root = new TreeNode(num[mid]);
+        root.left = sortedArrayToBST(num, start, mid - 1);
+        root.right = sortedArrayToBST(num, mid + 1, end);
+        return root;
+    }
+}

ZigZagPuzzle.java

@@ -3,7 +3,6 @@ public String convert(String s, int nRows) {
         // Start typing your Java solution below
         // DO NOT write main() function
         int length = s.length();
-        if (length == 0) return "";
         if (length <= nRows || nRows == 1) return s;
         char[] chars = new char[length];
         int step = 2 * (nRows - 1);