File is Added

Author: anjha1

0173.binary-search-tree-iterator/BinarySearchTreeIterator.java

@@ -0,0 +1,48 @@
+import java.util.Stack;
+
+/**
+ * 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 BSTIterator {
+    private final Stack<TreeNode> stack = new Stack<>();
+
+    private void pushAll(TreeNode node) {
+        while (node != null) {
+            stack.push(node);
+            node = node.left;
+        }
+    }
+
+    public BSTIterator(TreeNode root) {
+        pushAll(root);
+    }
+    
+    public int next() {
+        TreeNode tempNode = stack.pop();
+        pushAll(tempNode.right);
+        return tempNode.val;
+    }
+    
+    public boolean hasNext() {
+        return !stack.isEmpty();
+    }
+}
+
+/**
+ * Your BSTIterator object will be instantiated and called as such:
+ * BSTIterator obj = new BSTIterator(root);
+ * int param_1 = obj.next();
+ * boolean param_2 = obj.hasNext();
+ */

0173.binary-search-tree-iterator/README.md

@@ -0,0 +1,2 @@
+# [173. Binary Search Tree Iterator](https://leetcode.com/problems/binary-search-tree-iterator/)
+

0188.best-time-to-buy-and-sell-stock-iv/BestTimeToBuyAndSellStockIv.java

@@ -0,0 +1,23 @@
+class BestTimeToBuyAndSellStockIv {
+    public int maxProfit(int k, int[] prices) {
+        int n = prices.length;
+        if (n <= 1) return 0;
+        if (k >= n / 2) {
+            int maxPro = 0;
+            for (int i = 1; i < n; i++) {
+                if (prices[i] > prices[i - 1]) maxPro += prices[i] - prices[i - 1];
+            }
+            return maxPro;
+        }
+
+        int[][] dp = new int[k + 1][n];
+        for (int i = 1; i <= k; i++) {
+            int localMax = dp[i - 1][0] - prices[0];
+            for (int j = 1; j < n; j++) {
+                dp[i][j] = Math.max(dp[i][j - 1], prices[j] + localMax);
+                localMax = Math.max(localMax, dp[i - 1][j] - prices[j]);
+            }
+        }
+        return dp[k][n - 1];
+    }
+}

0188.best-time-to-buy-and-sell-stock-iv/README.md

@@ -0,0 +1,2 @@
+# [188. Best Time to Buy and Sell Stock IV](https://leetcode.com/problems/best-time-to-buy-and-sell-stock-iv/)
+

0189.rotate-array/README.md

@@ -0,0 +1 @@
+# [189. Rotate Array](https://leetcode.com/problems/rotate-array/)

0189.rotate-array/RotateArray.java

@@ -0,0 +1,27 @@
+class RotateArray {
+    private void reverse(int[] nums, int l, int r) {
+        while (l < r) {
+            int temp = nums[l];
+            nums[l] = nums[r];
+            nums[r] = temp;
+            l++;
+            r--;
+        }
+    }
+
+    public void rotate(int[] nums, int k) {
+        k = k % nums.length;
+        // reverse array
+        int l = 0, r = nums.length - 1;
+        reverse(nums, l, r);
+
+        // reverse left part
+        r = k - 1;
+        reverse(nums, l, r);
+
+        // reverse right part
+        l = k;
+        r = nums.length - 1;
+        reverse(nums, l, r);
+    }
+}

0190.reverse-bits/README.md

@@ -0,0 +1,2 @@
+# [190. Reverse Bits](https://leetcode.com/problems/reverse-bits/)
+

0190.reverse-bits/ReverseBits.java

@@ -0,0 +1,12 @@
+public class ReverseBits {
+    // you need treat n as an unsigned value
+    public int reverseBits(int n) {
+        int ret = 0;
+        for (int i = 0; i < 32; i++) {
+            ret <<= 1;
+            ret |= (n & 1);
+            n >>= 1;
+        }
+        return ret;
+    }
+}

0191.number-of-1-bits/NumberOf1Bits.java

@@ -0,0 +1,16 @@
+public class NumberOf1Bits {
+    // you need to treat n as an unsigned value
+    public int hammingWeight(int n) {
+        int cnt = 0;
+        // deal with sign part
+        if (n < 0) {
+            cnt++;
+            n = n + 1 + Integer.MAX_VALUE;
+        }
+        while (n != 0) {
+            if ((n & 1) == 1) cnt++;
+            n = n >> 1;
+        }
+        return cnt;
+    }
+}

0191.number-of-1-bits/README.md

@@ -0,0 +1,2 @@
+# [191. Number of 1 Bits](https://leetcode.com/problems/number-of-1-bits/)
+

0198.house-robber/HouseRobber.java

@@ -0,0 +1,14 @@
+class HouseRobber {
+    public int rob(int[] nums) {
+        int n = nums.length;
+        if (n == 0) return 0;
+        if (n == 1) return nums[0];
+        int[] dp = new int[n];
+        dp[0] = nums[0];
+        dp[1] = Math.max(nums[0], nums[1]);
+        for (int i = 2; i < n; i++)
+            dp[i] = Math.max(dp[i - 2] + nums[i], dp[i - 1]);
+
+        return dp[n - 1];
+    }
+}

0198.house-robber/README.md

@@ -0,0 +1,7 @@
+# [198. House Robber](https://leetcode.com/problems/house-robber/)
+
+
+Complexity Analysis:
+
+- Time Complexity: $O(n)$. $n$ is the length of `nums`.
+- Space Complexity: $O(1)$.

0199.binary-tree-right-side-view/BinaryTreeRightSideView.java

@@ -0,0 +1,36 @@
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * 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 BinaryTreeRightSideView {
+    private void rightSideViewHelper(TreeNode root, int level, List<Integer> list) {
+        if (root == null) {
+            return;
+        }
+        if (level == list.size()) {
+            list.add(root.val);
+        }
+        rightSideViewHelper(root.right, level + 1, list);
+        rightSideViewHelper(root.left, level + 1, list);
+    }
+
+    public List<Integer> rightSideView(TreeNode root) {
+        List<Integer> list = new ArrayList<>();
+        rightSideViewHelper(root, 0, list);
+        return list;
+    }
+}

0199.binary-tree-right-side-view/README.md

@@ -0,0 +1 @@
+# [199. Binary Tree Right Side View](https://leetcode.com/problems/binary-tree-right-side-view/)

0200.number-of-islands/NumberOfIslands.java

@@ -0,0 +1,28 @@
+class NumberOfIslands {
+    private int m;
+    private int n;
+
+    private void DFSMarking(char[][] grid, int i, int j) {
+        if (i < 0 || j < 0 || i >= m || j >= n || grid[i][j] == '0') return;
+        grid[i][j] = '0';
+        DFSMarking(grid, i + 1, j);
+        DFSMarking(grid, i - 1, j);
+        DFSMarking(grid, i, j + 1);
+        DFSMarking(grid, i, j - 1);
+    }
+
+    public int numIslands(char[][] grid) {
+        int island = 0;
+        m = grid.length;
+        n = grid[0].length;
+        for (int i = 0; i < m; i++) {
+            for (int j = 0; j < n; j++) {
+                if (grid[i][j] == '1') {
+                    DFSMarking(grid, i, j);
+                    island++;
+                }
+            }
+        }
+        return island;
+    }
+}

0200.number-of-islands/README.md

@@ -0,0 +1,2 @@
+# [200. Number of Islands](https://leetcode.com/problems/number-of-islands/)
+

0202.happy-number/HappyNumber.java

@@ -0,0 +1,29 @@
+import java.util.HashMap;
+import java.util.Map;
+
+class HappyNumber {
+    private int happyNumber(int n) {
+        int res = 0;
+        while (n > 0) {
+            int num = n % 10;
+            res += num * num;
+            n /= 10;
+        }
+        return res;
+    }
+
+    public boolean isHappy(int n) {
+        Map<Integer, Integer> map = new HashMap<>();
+        int happyNumber = n;
+        map.put(happyNumber, 1);
+        while (happyNumber != 0 && happyNumber != 1) {
+            happyNumber = happyNumber(happyNumber);
+            if (map.containsKey(happyNumber)) {
+                return false;
+            } else {
+                map.put(happyNumber, 1);
+            }
+        }
+        return happyNumber == 1;
+    }
+}

0202.happy-number/README.md

@@ -0,0 +1 @@
+# [202. Happy Number](https://leetcode.com/problems/happy-number/)

0205.isomorphic-strings/IsomorphicStrings.java

@@ -0,0 +1,15 @@
+class IsomorphicStrings {
+    public boolean isIsomorphic(String s, String t) {
+        int[] preIndexOfs = new int[256];
+        int[] preIndexOft = new int[256];
+        for (int i = 0; i < s.length(); i++) {
+            char sc = s.charAt(i), tc = t.charAt(i);
+            if (preIndexOfs[sc] != preIndexOft[tc]) {
+                return false;
+            }
+            preIndexOfs[sc] = i + 1;
+            preIndexOft[tc] = i + 1;
+        }
+        return true;
+    }
+}

0205.isomorphic-strings/README.md

@@ -0,0 +1 @@
+# [205. Isomorphic Strings](https://leetcode.com/problems/isomorphic-strings/)

0206.reverse-linked-list/README.md

@@ -0,0 +1,2 @@
+# [206. Reverse Linked List](https://leetcode.com/problems/reverse-linked-list/)
+

0206.reverse-linked-list/ReverseLinkedList.java

@@ -0,0 +1,22 @@
+/**
+ * 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 ReverseLinkedList {
+    public ListNode reverseList(ListNode head) {
+        if (head == null || head.next == null) {
+            return head;
+        }
+        ListNode next = head.next;
+        ListNode newHead = reverseList(next);
+        next.next = head;
+        head.next = null;
+        return newHead;
+    }
+}

0207.course-schedule/CourseSchedule.java

@@ -0,0 +1,40 @@
+import java.util.ArrayList;
+import java.util.List;
+
+class CourseSchedule {
+    private boolean hasCycle(boolean[] globalMarked, boolean[] localMarked, List<Integer>[] graphic, int curNode) {
+        if (localMarked[curNode]) {
+            return true;
+        }
+        if (globalMarked[curNode]) {
+            return false;
+        }
+        globalMarked[curNode] = true;
+        localMarked[curNode] = true;
+        for (int nextNode : graphic[curNode]) {
+            if (hasCycle(globalMarked, localMarked, graphic, nextNode)) {
+                return true;
+            }
+        }
+        localMarked[curNode] = false;
+        return false;
+    }
+
+    public boolean canFinish(int numCourses, int[][] prerequisites) {
+        List<Integer>[] graphic = new List[numCourses];
+        for (int i = 0; i < numCourses; i++) {
+            graphic[i] = new ArrayList<>();
+        }
+        for (int[] pre : prerequisites) {
+            graphic[pre[0]].add(pre[1]);
+        }
+        boolean[] globalMarked = new boolean[numCourses];
+        boolean[] localMarked = new boolean[numCourses];
+        for (int i = 0; i < numCourses; i++) {
+            if (hasCycle(globalMarked, localMarked, graphic, i)) {
+                return false;
+            }
+        }
+        return true;
+    }
+}

0207.course-schedule/README.md

@@ -0,0 +1 @@
+# [207. Course Schedule](https://leetcode.com/problems/course-schedule/)