Medium

leetcode/medium/107_binary-tree-level-order-traversal-ii.java

@@ -0,0 +1,45 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+
+    public List<List<Integer>> levelOrderBottom(TreeNode root) {
+        if (root == null) return new ArrayList<>();
+
+        List<List<Integer>> list = new ArrayList<>();
+
+        dfs(root, 0, list);
+
+        int size = list.size();
+        for (int i = 0; i < size / 2; i++) {
+            List<Integer> newList = list.get(i);
+            list.set(i, list.get(size - i - 1));
+            list.set(size - i - 1, newList);
+        }
+
+        return list;
+    }
+
+    public void dfs(TreeNode node, int level, List<List<Integer>> list) {
+        if (node == null) return;
+
+        if (level == list.size()) list.add(new ArrayList<>());
+
+        list.get(level).add(node.val);
+
+        dfs(node.left, level + 1, list);
+        dfs(node.right, level + 1, list);
+    }
+}

leetcode/medium/114_flatten-binary-tree-to-linked-list.java

@@ -0,0 +1,30 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+
+    private TreeNode prev = null;
+
+    public void flatten(TreeNode root) {
+        if (root == null) return;
+
+        flatten(root.right); // right first
+        flatten(root.left);
+
+        root.right = prev;
+        root.left = null;
+        prev = root;
+    }
+}

leetcode/medium/151_reverse-words-in-a-string.java

@@ -0,0 +1,31 @@
+class Solution {
+
+    public String reverseWords(String s) {
+        char[] st = s.toCharArray();
+        char[] arr = new char[st.length];
+        int ind = reversewordslength(st, arr, 0);
+        return new String(arr, 0, ind);
+    }
+
+    public int reversewordslength(char[] st, char[] arr, int start) {
+        while (start < st.length && st[start] == ' ') {
+            start++;
+        }
+        int end = start;
+        while (end < st.length && st[end] != ' ') {
+            end++;
+        }
+        if (start - end == 0) {
+            return 0;
+        }
+        int reversedwordlen = reversewordslength(st, arr, end);
+        if (reversedwordlen != 0) {
+            arr[reversedwordlen] = ' ';
+            reversedwordlen++;
+        }
+        while (start < end) {
+            arr[reversedwordlen++] = st[start++];
+        }
+        return reversedwordlen;
+    }
+}

leetcode/medium/152_maximum-product-subarray.java

@@ -0,0 +1,23 @@
+class Solution {
+
+    public int maxProduct(int[] nums) {
+        var maxProd = Integer.MIN_VALUE;
+        var prod = 1;
+        for (var i = 0; i < nums.length; i++) {
+            prod *= nums[i];
+            maxProd = Math.max(prod, maxProd);
+            if (prod == 0) {
+                prod = 1;
+            }
+        }
+        prod = 1;
+        for (var i = nums.length - 1; i >= 0; i--) {
+            prod *= nums[i];
+            maxProd = Math.max(prod, maxProd);
+            if (prod == 0) {
+                prod = 1;
+            }
+        }
+        return maxProd;
+    }
+}

leetcode/medium/162_find-peak-element.java

@@ -0,0 +1,22 @@
+class Solution {
+
+    public int findPeakElement(int[] nums) {
+        int left = 0,
+            right = nums.length - 1;
+
+        while (left < right) {
+            int mid = left + (right - left) / 2;
+
+            if (nums[mid] > nums[mid + 1]) {
+                // Peak must be on the left (including mid)
+                right = mid;
+            } else {
+                // Peak must be on the right
+                left = mid + 1;
+            }
+        }
+
+        // left == right is the index of a peak
+        return left;
+    }
+}

leetcode/medium/17_letter-combinations-of-a-phone-number.java

@@ -0,0 +1,43 @@
+class Solution {
+
+    String[] mapping = new String[] {
+        "",
+        "",
+        "abc",
+        "def",
+        "ghi",
+        "jkl",
+        "mno",
+        "pqrs",
+        "tuv",
+        "wxyz",
+    };
+    List<String> res = new ArrayList<>();
+
+    public void phoneComb(int idx, StringBuilder op, String digits) {
+        if (idx >= digits.length()) {
+            res.add(op.toString());
+            return;
+        }
+
+        String val = mapping[digits.charAt(idx) - '0'];
+
+        for (char ch : val.toCharArray()) {
+            op.append(ch);
+
+            phoneComb(idx + 1, op, digits);
+
+            op.deleteCharAt(op.length() - 1);
+        }
+    }
+
+    public List<String> letterCombinations(String digits) {
+        if (digits.length() == 0) {
+            return res;
+        }
+
+        phoneComb(0, new StringBuilder(), digits);
+
+        return res;
+    }
+}

leetcode/medium/50_powx-n.java

@@ -0,0 +1,16 @@
+class Solution {
+
+    public double myPow(double x, int n) {
+        return helper(x, (long) n);
+    }
+
+    private static double helper(double a, long b) {
+        if (b == 0) 
+            return 1;
+        if (b < 0) 
+            return 1 / helper(a, -b);
+        if (b % 2 != 0) 
+            return a * helper(a * a, (b - 1) / 2);
+        return helper(a * a, b / 2);
+    }
+}

leetcode/medium/54_spiral-matrix.java

@@ -0,0 +1,37 @@
+class Solution {
+
+    public List<Integer> spiralOrder(int[][] matrix) {
+        int left = 0,
+            right = matrix[0].length - 1;
+        int top = 0,
+            bottom = matrix.length - 1;
+        List<Integer> ans = new ArrayList<>();
+
+        while (left <= right && top <= bottom) {
+            for (int i = left; i <= right; i++) {
+                ans.add(matrix[top][i]);
+            }
+            top++;
+
+            for (int i = top; i <= bottom; i++) {
+                ans.add(matrix[i][right]);
+            }
+            right--;
+
+            if (top <= bottom) {
+                for (int i = right; i >= left; i--) {
+                    ans.add(matrix[bottom][i]);
+                }
+                bottom--;
+            }
+
+            if (left <= right) {
+                for (int i = bottom; i >= top; i--) {
+                    ans.add(matrix[i][left]);
+                }
+                left++;
+            }
+        }
+        return ans;
+    }
+}

leetcode/medium/59_spiral-matrix-ii.java

@@ -0,0 +1,41 @@
+class Solution {
+
+    public int[][] generateMatrix(int n) {
+        int index = 1;
+        int top = 0,
+            bottom = n - 1;
+        int left = 0,
+            right = n - 1;
+        int[][] matrix = new int[n][n];
+        while (top <= bottom && left <= right) {
+            for (int i = left; i <= right; i++) {
+                matrix[top][i] = index;
+                index++;
+            }
+            top++;
+
+            for (int i = top; i <= bottom; i++) {
+                matrix[i][right] = index;
+                index++;
+            }
+            right--;
+
+            if (top <= bottom) {
+                for (int i = right; i >= left; i--) {
+                    matrix[bottom][i] = index;
+                    index++;
+                }
+                bottom--;
+            }
+
+            if (left <= right) {
+                for (int i = bottom; i >= top; i--) {
+                    matrix[i][left] = index;
+                    index++;
+                }
+                left++;
+            }
+        }
+        return matrix;
+    }
+}

leetcode/medium/74_search-a-2d-matrix.java

@@ -0,0 +1,24 @@
+class Solution {
+
+    public boolean searchMatrix(int[][] matrix, int target) {
+        int m = matrix.length;
+        int n = matrix[0].length;
+
+        int left = 0;
+        int right = m * n - 1;
+
+        while (left <= right) {
+            int mid = left + (right - left) / 2;
+            int midValue = matrix[mid / n][mid % n];
+
+            if (midValue == target) {
+                return true;
+            } else if (midValue < target) {
+                left = mid + 1;
+            } else {
+                right = mid - 1;
+            }
+        }
+        return false;
+    }
+}

leetcode/medium/82_remove-duplicates-from-sorted-list-ii.java

@@ -0,0 +1,35 @@
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode() {}
+ *     ListNode(int val) { this.val = val; }
+ *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
+ * }
+ */
+class Solution {
+
+    public ListNode deleteDuplicates(ListNode head) {
+        if (head == null) {
+            return null;
+        }
+        ListNode dummy = new ListNode(0);
+        dummy.next = head;
+        ListNode prev = dummy;
+        ListNode t = head;
+
+        while (t != null) {
+            if (t.next != null && t.val == t.next.val) {
+                while (t.next != null && t.val == t.next.val) {
+                    t = t.next;
+                }
+                prev.next = t.next;
+            } else {
+                prev = prev.next;
+            }
+            t = t.next;
+        }
+        return dummy.next;
+    }
+}

leetcode/medium/8_string-to-integer-atoi.java

@@ -0,0 +1,31 @@
+class Solution {
+
+    public int myAtoi(String s) {
+        s = s.trim();
+        int sign = 1,
+            i = 0;
+        long res = 0;
+        if (s.length() == 0) {
+            return 0;
+        }
+        if (s.charAt(0) == '-') {
+            sign = -1;
+            i++;
+        } else if (s.charAt(0) == '+') {
+            i++;
+        }
+        while (i < s.length()) {
+            char ch = s.charAt(i);
+            if (ch < '0' || ch > '9') {
+                break;
+            }
+            res = res * 10 + (ch - '0');
+            if (sign * res > Integer.MAX_VALUE) 
+                return Integer.MAX_VALUE;
+            if (sign * res < Integer.MIN_VALUE) 
+                return Integer.MIN_VALUE;
+            i++;
+        }
+        return (int) (sign * res);
+    }
+}