Solved #22 #283 #669 #951

Author: rayworks

src/main/java/org/sean/array/ParenthesesGenerator.java

@@ -0,0 +1,35 @@
+package org.sean.array;
+
+import java.util.*;
+
+/** * 22. Generate Parentheses */
+public class ParenthesesGenerator {
+    private static final String pair = "()";
+    private Set<String> set = new HashSet<>();
+
+    public List<String> generateParenthesis(int n) {
+        if (n == 0) return Collections.emptyList();
+
+        if (n == 1) return Arrays.asList(pair);
+
+        return reduce(pair, generateParenthesis(n - 1));
+    }
+
+    private List<String> reduce(String s, List<String> strings) {
+        int size = strings.size();
+
+        set.clear();
+        for (int i = 0; i < size; i++) { // e.g [ ()(), (()) ]
+            String elem = strings.get(i);
+
+            set.add(elem + s);
+
+            int len = elem.length();
+            for (int j = 0; j < len; j++) {
+                set.add(elem.substring(0, j) + s + elem.substring(j));
+            }
+        }
+
+        return new LinkedList<>(set);
+    }
+}

src/main/java/org/sean/array/ZeroesMover.java

@@ -0,0 +1,32 @@
+package org.sean.array;
+
+/** * 283 Move Zeroes */
+public class ZeroesMover {
+    private void swap(int[] array, int i, int j) {
+        int tmp = array[i];
+        array[i] = array[j];
+        array[j] = tmp;
+    }
+
+    public void moveZeroes(int[] nums) {
+        if (nums != null || nums.length > 0) {
+            int zeroCnt = 0;
+            for (int i = 0; i < nums.length; i++) {
+                if (nums[i] != 0) {
+                    int p = i - 1;
+                    while (p >= 0) {
+                        if (nums[p] != 0) {
+                            break;
+                        }
+
+                        --p;
+                    }
+
+                    if ((p + 1) >= 0 && (p + 1) != i) {
+                        swap(nums, p + 1, i);
+                    }
+                }
+            }
+        }
+    }
+}

src/main/java/org/sean/tree/BinarySearchTreeTrimmer.java

@@ -0,0 +1,27 @@
+package org.sean.tree;
+
+/** * 669. Trim a Binary Search Tree */
+public class BinarySearchTreeTrimmer {
+    private TreeNode findNextNode(TreeNode node, int L, int R) {
+        if (node == null) {
+            return null;
+        }
+
+        if (node.val >= L && node.val <= R) return node;
+
+        if (node.val < L) {
+            return findNextNode(node.right, L, R);
+        } else {
+            return findNextNode(node.left, L, R);
+        }
+    }
+
+    public TreeNode trimBST(TreeNode root, int L, int R) {
+        root = findNextNode(root, L, R);
+
+        if (root != null) root.left = trimBST(root.left, L, R);
+        if (root != null) root.right = trimBST(root.right, L, R);
+
+        return root;
+    }
+}

src/main/java/org/sean/tree/FlipEquivalentTree.java

@@ -0,0 +1,51 @@
+package org.sean.tree;
+
+// 951 Flip Equivalent Binary Trees
+public class FlipEquivalentTree {
+
+    private boolean areNodesEqual(TreeNode t1, TreeNode t2) {
+        if (t1 == null && t2 == null) return true;
+        else if (t1 == null || t2 == null) return false;
+        else return t1.val == t2.val;
+    }
+
+    private void flip(TreeNode node) {
+        if (node != null) {
+            TreeNode tmp = node.left;
+            node.left = node.right;
+            node.right = tmp;
+        }
+    }
+
+    private boolean isLeaf(TreeNode node) {
+        if (node != null) {
+            return node.left == null && node.right == null;
+        }
+        return false;
+    }
+
+    public boolean flipEquiv(TreeNode root1, TreeNode root2) {
+        if (root1 == null && root2 == null) {
+            return true;
+        } else if (root1 == null || root2 == null) {
+            return false;
+        } else {
+            if (root1.val == root2.val) {
+                if (isLeaf(root1) && isLeaf(root2)) {
+                    return true;
+                } else {
+                    if (!areNodesEqual(root1.left, root2.left)) {
+                        flip(root1);
+                    }
+
+                    boolean leftResult = flipEquiv(root1.left, root2.left);
+                    boolean rightResult = flipEquiv(root1.right, root2.right);
+
+                    return leftResult && rightResult;
+                }
+            } else {
+                return false;
+            }
+        }
+    }
+}