update java solution

Author: tiationg-kho

README.md

@@ -0,0 +1,44 @@
+/**
+ * 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>> levelOrder(TreeNode root) {
+        List<List<Integer>> res = new ArrayList<>();
+        if (root == null) {
+            return res;
+        }
+        ArrayDeque<TreeNode> queue = new ArrayDeque<>();
+        queue.offer(root);
+        while (!queue.isEmpty()) {
+            ArrayList<Integer> cur = new ArrayList<>();
+            int levelCount = queue.size();
+            for (int i = 0; i < levelCount; i++) {
+                TreeNode node = queue.poll();
+                cur.add(node.val);
+                for (TreeNode child: new TreeNode[]{node.left, node.right}) {
+                    if (child != null) {
+                        queue.offer(child);
+                    }
+                }
+            }
+            res.add(cur);
+        }
+        return res;
+    }
+}
+
+// time O(n), due to traversal
+// space O(n), queue can have a size of n/2 or the list's size to store nodes
+// using tree and bfs

[A]tree/[A]tree-bfs/102-binary-tree-level-order-traversal.java

@@ -0,0 +1,25 @@
+class Solution {
+    public int lengthOfLongestSubstring(String s) {
+        HashMap<Character, Integer> charToFreq = new HashMap<>();
+        int res = 0;
+        int left = 0;
+        for (int right = 0; right < s.length(); right++) {
+            Character c = s.charAt(right);
+            charToFreq.compute(c, (k, v) -> v == null ? 1 : v + 1);
+            while (charToFreq.get(c) > 1) {
+                Character removeC = s.charAt(left);
+                charToFreq.put(removeC, charToFreq.get(removeC) - 1);
+                if (Objects.equals(charToFreq.get(removeC), 0)) {
+                    charToFreq.remove(removeC);
+                }
+                left += 1;
+            }
+            res = Math.max(res, right - left + 1);
+        }
+        return res;
+    }
+}
+
+// time O(n)
+// space O(1), due to the hashmap could contain all unique chars
+// using array and standard sliding window and hashmap

[H]array/[H]array-sliding-window/3-longest-substring-without-repeating-characters.java

@@ -0,0 +1,46 @@
+class Solution {
+    public List<List<Integer>> threeSum(int[] nums) {
+        Arrays.sort(nums);
+        List<List<Integer>> res = new ArrayList<>();
+        for (int i = 0; i < nums.length - 2; i++) {
+            if (i - 1 >= 0 && nums[i - 1] == nums[i]) {
+                continue;
+            }
+            int j = i + 1;
+            int k = nums.length - 1;
+            int target = 0 - nums[i];
+            if (nums[j] + nums[j + 1] > target) {
+                break;
+            }
+            if (nums[k - 1] + nums[k] < target) {
+                continue;
+            }
+            while (j < k) {
+                int total = nums[j] + nums[k];
+                if (total == target) {
+                    res.add(new ArrayList<>(Arrays.asList(nums[i], nums[j], nums[k])));
+                    j += 1;
+                    k -= 1;
+                } else if (total > target) {
+                    k -= 1;
+                } else {
+                    j += 1;
+                }
+                while (j < k && j - 1 > i && nums[j - 1] == nums[j]) {
+                    j += 1;
+                }
+                while (j < k && k + 1 < nums.length && nums[k] == nums[k + 1]) {
+                    k -= 1;
+                }
+            }
+        }
+        return res;
+    }
+}
+
+// time O(n**2)
+// space O(1), or due to built in sort's cost
+// using array and two pointers opposite direction and shrink type and sort
+/*
+1. be aware of handling duplicate
+*/

[H]array/[H]array-two-pointers-opposite-direction/15-3sum.java

@@ -0,0 +1,27 @@
+class Solution {
+    public int evalRPN(String[] tokens) {
+        ArrayDeque<Integer> stack = new ArrayDeque<>();
+        for (String token: tokens) {
+            if ("+-*/".contains(token)) {
+                Integer second = stack.pop();
+                Integer first = stack.pop();
+                if (Objects.equals(token, "+")){
+                    stack.push(first + second);
+                } else if (Objects.equals(token, "-")) {
+                    stack.push(first - second);
+                } else if (Objects.equals(token, "*")) {
+                    stack.push(first * second);
+                } else {
+                    stack.push(first / second);
+                }
+            } else {
+                stack.push(Integer.parseInt(token));
+            }
+        }
+        return stack.peek();
+    }
+}
+
+// time O(n), due to traverse
+// space O(n), due to stack
+// using stack and queue and use stack to store the last states

[I]stack-queue/[I]stack-queue/150-evaluate-reverse-polish-notation.java

@@ -0,0 +1,48 @@
+/*
+// Definition for a Node.
+class Node {
+    public int val;
+    public List<Node> neighbors;
+    public Node() {
+        val = 0;
+        neighbors = new ArrayList<Node>();
+    }
+    public Node(int _val) {
+        val = _val;
+        neighbors = new ArrayList<Node>();
+    }
+    public Node(int _val, ArrayList<Node> _neighbors) {
+        val = _val;
+        neighbors = _neighbors;
+    }
+}
+*/
+
+class Solution {
+    public Node cloneGraph(Node node) {
+        HashMap<Node, Node> oldToNew = new HashMap<>();
+        if (node == null) {
+            return node;
+        }
+        oldToNew.put(node, new Node(node.val));
+        ArrayDeque<Node> queue = new ArrayDeque<>();
+        queue.offer(node);
+        while (!queue.isEmpty()) {
+            Node oldNode = queue.poll();
+            Node newNode = oldToNew.get(oldNode);
+            for (Node neighbor: oldNode.neighbors) {
+                if (!oldToNew.containsKey(neighbor)) {
+                    oldToNew.put(neighbor, new Node(neighbor.val));
+                    queue.offer(neighbor);
+                }
+                Node newNeighbor = oldToNew.get(neighbor);
+                newNode.neighbors.add(newNeighbor);
+            }
+        }
+        return oldToNew.get(node);
+    }
+}
+
+// time O(n)
+// space O(n)
+// using graph and bfs with single source and hashmap

[K]graph/[K]graph-bfs/133-clone-graph.java

@@ -2078,12 +2078,17 @@ public class Main {
         System.out.println(s5); // Hello World!!
         System.out.println("-----");
 
-        // String from int O(logn) (base 10) or O(1)
+        // String from int in O(logn) (base 10) or O(1)
         int i = 1001;
         String iString = i + "";
         System.out.println(iString); // 1001
         System.out.println("-----");
 
+        // String to int in O(n)
+        int intFromString = Integer.parseInt(iString);
+        System.out.println(intFromString); // 1001
+        System.out.println("-----");
+
         // char related methods
         char c1 = 'a';
         char c2 = 'A';
@@ -2293,6 +2298,7 @@ public class Main {
 ```Java
 package NumberSyntax;
 
+import java.util.Objects;
 import java.util.Random;
 
 public class Main {
@@ -2393,16 +2399,14 @@ public class Main {
             Character.compare(x, y)
 
         03. int x, Integer y. use:
-            x == y (notice: not null-safe)
-            x != y (notice: not null-safe)
+            Objects.equals(x, y)
             x > y (notice: not null-safe)
             x < y (notice: not null-safe)
             x >= y (notice: not null-safe)
             x <= y (notice: not null-safe)
 
         04. char x, Character y. use:
-            x == y (notice: not null-safe)
-            x != y (notice: not null-safe)
+            Objects.equals(x, y)
             x > y (notice: not null-safe)
             x < y (notice: not null-safe)
             x >= y (notice: not null-safe)