萤火虫-添加其它之前做过的题

Author: yasinshaw

src/main/java/N101_200/N101.java

@@ -0,0 +1,32 @@
+package N101_200;
+
+/**
+ * @author Yasin Shaw
+ * @version v1.0
+ */
+public class N101 {
+
+    private class TreeNode {
+        int val;
+        TreeNode left;
+        TreeNode right;
+
+        TreeNode(int x) {
+            val = x;
+        }
+    }
+
+    public boolean isSymmetric(TreeNode root) {
+        return root == null ? true : isSymmetric(root.left, root.right);
+    }
+
+    private boolean isSymmetric(TreeNode left, TreeNode right) {
+        if (left == null && right == null) {
+            return true;
+        } else if (left == null || right == null) {
+            return false;
+        } else {
+            return left.val == right.val && isSymmetric(left.left, right.right) && isSymmetric(left.right, right.left);
+        }
+    }
+}

src/main/java/N101_200/N104.java

@@ -0,0 +1,30 @@
+package N101_200;
+
+/**
+ * @author Yasin Shaw
+ * @version v1.0
+ */
+public class N104 {
+
+    private class TreeNode {
+        int val;
+        TreeNode left;
+        TreeNode right;
+
+        TreeNode(int x) {
+            val = x;
+        }
+    }
+
+    public int maxDepth(TreeNode root) {
+        return getNextDepth(root, 0);
+    }
+
+    private int getNextDepth(TreeNode root, int currentDepth) {
+        if (root == null) {
+            return currentDepth;
+        } else {
+            return Math.max(getNextDepth(root.left, currentDepth + 1), getNextDepth(root.right, currentDepth + 1));
+        }
+    }
+}

src/main/java/N101_200/N107.java

@@ -0,0 +1,54 @@
+package N101_200;
+
+import java.util.ArrayList;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.stream.Collectors;
+
+/**
+ * @author Yasin Shaw
+ * @version v1.0
+ */
+public class N107 {
+    private class TreeNode {
+        int val;
+        TreeNode left;
+        TreeNode right;
+
+        TreeNode(int x) {
+            val = x;
+        }
+    }
+
+    public List<List<Integer>> levelOrderBottom(TreeNode root) {
+        List<TreeNode> treeNodes = new ArrayList<>(1);
+        if (root == null) {
+            return new LinkedList<>();
+        }
+        treeNodes.add(root);
+        return getThisLevel(treeNodes);
+    }
+
+    private List<List<Integer>> getThisLevel(List<TreeNode> treeNodes) {
+        List<TreeNode> thisLevelTreeNodes = new LinkedList<>();
+        List<Integer> thisLevelValues = treeNodes.stream().map(treeNode -> treeNode.val).collect(Collectors.toList());
+        treeNodes.forEach(treeNode -> {
+            if (treeNode.left != null) {
+                thisLevelTreeNodes.add(treeNode.left);
+            }
+            if (treeNode.right != null) {
+                thisLevelTreeNodes.add(treeNode.right);
+            }
+        });
+
+        List<List<Integer>> result = new LinkedList<>();
+        if (treeNodes.size() > 0) {
+            List<List<Integer>> nextLevel = getThisLevel(thisLevelTreeNodes);
+            if (nextLevel.get(0).size() > 0) {
+                result.addAll(nextLevel);
+            }
+        }
+        result.add(thisLevelValues);
+        return result;
+    }
+}

src/main/java/N101_200/N108.java

@@ -0,0 +1,36 @@
+package N101_200;
+
+/**
+ * @author Yasin Shaw
+ * @version v1.0
+ */
+public class N108 {
+
+    private class TreeNode {
+        int val;
+        TreeNode left;
+        TreeNode right;
+
+        TreeNode(int x) {
+            val = x;
+        }
+    }
+
+    public TreeNode sortedArrayToBST(int[] nums) {
+        if (nums == null || nums.length == 0) {
+            return null;
+        }
+        return helper(nums, 0, nums.length - 1);
+    }
+
+    private TreeNode helper(int[] nums, int start, int end) {
+        if (start > end) {
+            return null;
+        }
+        int mid = start + (end - start) / 2;
+        TreeNode root = new TreeNode(nums[mid]);
+        root.left = helper(nums, start, mid - 1);
+        root.right = helper(nums, mid + 1, end);
+        return root;
+    }
+}

src/main/java/N101_200/N110.java

@@ -0,0 +1,28 @@
+package N101_200;
+
+import common.TreeNode;
+
+/**
+ * @author Yasin Shaw
+ * @version v1.0
+ */
+public class N110 {
+    public boolean isBalanced(TreeNode root) {
+        if (root == null) {
+            return true;
+        }
+        int left = search(root.left, 0);
+        int right = search(root.right, 0);
+        if (Math.abs(left - right) > 1) {
+            return false;
+        }
+        return isBalanced(root.left) && isBalanced(root.right);
+    }
+
+    private int search(TreeNode treeNode, int count) {
+        if (treeNode == null) {
+            return count;
+        }
+        return Math.max(search(treeNode.left, count + 1), search(treeNode.right, count + 1));
+    }
+}

src/main/java/N101_200/N111.java

@@ -0,0 +1,28 @@
+package N101_200;
+
+import common.TreeNode;
+
+/**
+ * @author Yasin Shaw
+ * @version v1.0
+ */
+public class N111 {
+    public int minDepth(TreeNode root) {
+        return minDepth(root, 0);
+    }
+
+    private int minDepth(TreeNode root, int count) {
+        int depth = count;
+        if (root != null) {
+            depth++;
+            if (root.left == null) {
+                depth = minDepth(root.right, depth);
+            } else if (root.right == null) {
+                depth = minDepth(root.left, depth);
+            } else {
+                depth = Math.min(minDepth(root.left, depth), minDepth(root.right, depth));
+            }
+        }
+        return depth;
+    }
+}

src/main/java/N101_200/N112.java

@@ -0,0 +1,22 @@
+package N101_200;
+
+import common.TreeNode;
+
+/**
+ * @author Yasin Shaw
+ * @version v1.0
+ */
+public class N112 {
+    public boolean hasPathSum(TreeNode root, int sum) {
+        if (root == null) {
+            return false;
+        }
+
+        if (root.left == null && root.right == null) {
+            return root.val == sum;
+        } else {
+            sum -= root.val;
+            return hasPathSum(root.left, sum) || hasPathSum(root.right, sum);
+        }
+    }
+}

src/main/java/N101_200/N118.java

@@ -0,0 +1,31 @@
+package N101_200;
+
+import java.util.LinkedList;
+import java.util.List;
+
+/**
+ * @author Yasin Shaw
+ * @version v1.0
+ */
+public class N118 {
+    public List<List<Integer>> generate(int numRows) {
+        List<List<Integer>> result = new LinkedList<>();
+        List<Integer> first = new LinkedList<>();
+        if (numRows >= 1) {
+            first.add(1);
+            List<Integer> previous = first;
+            result.add(first);
+            for (int i = 1; i < numRows; i++) {
+                List<Integer> current = new LinkedList<>();
+                current.add(1);
+                for (int j = 0; j < previous.size() - 1; j++) {
+                    current.add(previous.get(j) + previous.get(j + 1));
+                }
+                current.add(1);
+                previous = current;
+                result.add(current);
+            }
+        }
+        return result;
+    }
+}

src/main/java/N101_200/N119.java

@@ -0,0 +1,20 @@
+package N101_200;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * @author Yasin Shaw
+ * @version v1.0
+ */
+public class N119 {
+    public List<Integer> getRow(int rowIndex) {
+        List<Integer> row = new ArrayList<>(rowIndex + 1);
+        for (int i = 0; i <= rowIndex; i++) {
+            for (int j = i - 1; j >= 1; j--)
+                row.set(j, row.get(j - 1) + row.get(j));
+            row.add(1);
+        }
+        return row;
+    }
+}

src/main/java/N101_200/N121.java

@@ -0,0 +1,18 @@
+package N101_200;
+
+/**
+ * @author Yasin Shaw
+ * @version v1.0
+ */
+public class N121 {
+    public int maxProfit(int[] prices) {
+        if (prices.length < 2) return 0;
+        int profit = 0;
+        int low = prices[0];
+        for (int i = 1; i < prices.length; i++) {
+            low = Math.min(prices[i], low);
+            profit = Math.max(prices[i] - low, profit);
+        }
+        return profit;
+    }
+}

src/main/java/N101_200/N122.java

@@ -0,0 +1,17 @@
+package N101_200;
+
+/**
+ * @author Yasin Shaw
+ * @version v1.0
+ */
+public class N122 {
+    public int maxProfit(int[] prices) {
+        if (prices == null || prices.length == 0)
+            return 0;
+        int profile = 0;
+        for (int i = 0; i < prices.length - 1; i++)
+            if (prices[i] < prices[i + 1])
+                profile += prices[i + 1] - prices[i];
+        return profile;
+    }
+}

src/main/java/N101_200/N125.java

@@ -0,0 +1,31 @@
+package N101_200;
+
+/**
+ * @author Yasin Shaw
+ * @version v1.0
+ */
+public class N125 {
+    public boolean isPalindrome(String s) {
+        char[] chars = s.toCharArray();
+        for (int i = 0, j = chars.length - 1; i <= j; i++, j--) {
+            while (i < j && isNotAlphanumeric(chars[i])) {
+                i++;
+            }
+            while (i < j && isNotAlphanumeric(chars[j])) {
+                j--;
+            }
+            if (!equalsIgnoreCase(chars[i], chars[j])) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    private boolean isNotAlphanumeric(char c) {
+        return !Character.isAlphabetic(c) && !Character.isDigit(c);
+    }
+
+    private boolean equalsIgnoreCase(char a, char b) {
+        return Character.toLowerCase(a) == Character.toLowerCase(b);
+    }
+}

src/main/java/N101_200/N136.java

@@ -0,0 +1,17 @@
+package N101_200;
+
+/**
+ * @author Yasin Shaw
+ * @version v1.0
+ */
+public class N136 {
+    public int singleNumber(int[] nums) {
+        int ans = 0;
+
+        int len = nums.length;
+        for (int i = 0; i != len; i++)
+            ans ^= nums[i];
+
+        return ans;
+    }
+}

src/main/java/N101_200/N141.java

@@ -0,0 +1,21 @@
+package N101_200;
+
+import common.ListNode;
+
+/**
+ * @author Yasin Shaw
+ * @version v1.0
+ */
+public class N141 {
+    public boolean hasCycle(ListNode head) {
+        if (head == null) return false;
+        ListNode walker = head;
+        ListNode runner = head;
+        while (runner.next != null && runner.next.next != null) {
+            walker = walker.next;
+            runner = runner.next.next;
+            if (walker == runner) return true;
+        }
+        return false;
+    }
+}