update

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 {
+
+    record Pair(TreeNode node, int level) { };
+
+    public int maxDepth(TreeNode root) {
+        int res = 0;
+        if (root == null) {
+            return 0;
+        }
+        ArrayDeque<Pair> queue = new ArrayDeque<>();
+        queue.offer(new Pair(root, 1));
+        while (!queue.isEmpty()) {
+            Pair pair = queue.poll();
+            TreeNode node = pair.node;
+            int level = pair.level;
+            res = Math.max(res, level);
+            for (TreeNode child: new TreeNode[]{node.left, node.right}) {
+                if (child != null) {
+                    queue.offer(new Pair(child, level + 1));
+                }
+            }
+        }
+        return res;
+    }
+}
+
+// time O(n), due to bfs
+// space O(n), due to queue's size, it can be n/2 in a balanced tree's deepest level
+// using tree and bfs

[A]tree/[A]tree-bfs/104-maximum-depth-of-binary-tree.java

@@ -0,0 +1,40 @@
+/**
+ * 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 {
+
+  int res;
+
+  public int diameterOfBinaryTree(TreeNode root) {
+      res = 0;
+      dfs(root);
+      return res;
+  }
+
+  public int dfs(TreeNode node) {
+      if (node == null) {
+          return 0;
+      }
+      int leftL = dfs(node.left);
+      int rightL = dfs(node.right);
+      int nodeAsPeakL = leftL + rightL;
+      res = Math.max(res, nodeAsPeakL);
+      return Math.max(leftL + 1, rightL + 1);
+  }
+}
+
+// time O(n), due to traverse
+// space O(n), due to tree height for skewed tree
+// using tree and dfs (postorder, recursive)

[A]tree/[A]tree-dfs-postorder/543-diameter-of-binary-tree.java

@@ -0,0 +1,30 @@
+/**
+ * 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 reverseList(ListNode head) {
+        if (head == null || head.next == null) {
+            return head;
+        }
+        ListNode prev = null;
+        ListNode cur = head;
+        while (cur != null) {
+            ListNode nxt = cur.next;
+            cur.next = prev;
+            prev = cur;
+            cur = nxt;
+        }
+        return prev;
+    }
+}
+
+// time O(n)
+// space O(1)
+// using linked list and two pointers (prev and cur)

[B]linked-list/[B]linked-list/206-reverse-linked-list.java

@@ -0,0 +1,29 @@
+/**
+ * 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 middleNode(ListNode head) {
+      ListNode slow = head;
+      ListNode fast = head;
+      while (fast != null && fast.next != null) {
+          slow = slow.next;
+          fast = fast.next.next;
+      }
+      return slow;
+  }
+}
+
+// time O(n), due to traverse
+// space O(1)
+// using linked list and two pointers (slow and fast)
+/*
+1. If there are two middle nodes, return the second middle node: use 'while fast and fast.next'
+2. If there are two middle nodes, return the first middle node: use 'while fast.next and fast.next.next'
+*/

[B]linked-list/[B]linked-list/876-middle-of-the-linked-list.java

@@ -0,0 +1,27 @@
+class Solution {
+    public int romanToInt(String s) {
+        HashMap<Character, Integer> charToWeight = new HashMap<>();
+        charToWeight.put('I', 1);
+        charToWeight.put('V', 5);
+        charToWeight.put('X', 10);
+        charToWeight.put('L', 50);
+        charToWeight.put('C', 100);
+        charToWeight.put('D', 500);
+        charToWeight.put('M', 1000);
+        int res = 0;
+        for (int i = 0; i < s.length(); i++) {
+            Character c = s.charAt(i);
+            int w = charToWeight.get(c);
+            if (i + 1 < s.length() && charToWeight.get(s.charAt(i + 1)) > w) {
+                res -= w;
+            } else {
+                res += w;
+            }
+        }
+        return res;
+    }
+}
+
+// time O(n), due to traverse, n is the length of input string
+// space O(1), hashmap's size is O(7)
+// using hashmap and store val

[C]hashmap/[C]hashmap/13-roman-to-integer.java

@@ -0,0 +1,16 @@
+class Solution {
+    public boolean containsDuplicate(int[] nums) {
+        HashSet<Integer> set = new HashSet<>();
+        for (int num: nums) {
+            if (set.contains(num)) {
+                return true;
+            }
+            set.add(num);
+        }
+        return false;
+    }
+}
+
+// time O(n)
+// space O(n)
+// using hashmap and store val and hashset

[C]hashmap/[C]hashmap/217-contains-duplicate.java

@@ -12,7 +12,7 @@ public boolean isAnagram(String s, String t) {
             tCharToFreq.compute(tc, (k, v) -> v == null ? 1 : v + 1);
         }
         for (Character c: sCharToFreq.keySet()) {
-            if (!sCharToFreq.get(c).equals(tCharToFreq.get(c))) {
+            if (!Objects.equals(sCharToFreq.get(c), tCharToFreq.get(c))) {
                 return false;
             }
         }

[C]hashmap/[C]hashmap/242-valid-anagram.java

@@ -0,0 +1,25 @@
+class Solution {
+    public boolean canConstruct(String ransomNote, String magazine) {
+        HashMap<Character, Integer> rCharToFreq = new HashMap<>();
+        HashMap<Character, Integer> mCharToFreq = new HashMap<>();
+        for (int i = 0; i < ransomNote.length(); i++) {
+            Character c = ransomNote.charAt(i);
+            rCharToFreq.compute(c, (k, v) -> v == null ? 1 : v + 1);
+        }
+        for (int i = 0; i < magazine.length(); i++) {
+            Character c = magazine.charAt(i);
+            mCharToFreq.compute(c, (k, v) -> v == null ? 1 : v + 1);
+        }
+        for (Character c: rCharToFreq.keySet()) {
+            if (mCharToFreq.containsKey(c) && rCharToFreq.get(c) <= mCharToFreq.get(c)) {
+                continue;
+            }
+            return false;
+        }
+        return true;
+    }
+}
+
+// time O(n+m)
+// space O(26) == O(1), constant
+// using hashmap and store sth’s freq

[C]hashmap/[C]hashmap/383-ransom-note.java

@@ -0,0 +1,28 @@
+class Solution {
+    public int longestPalindrome(String s) {
+        HashMap<Character, Integer> charToFreq = new HashMap<>();
+        for (int i = 0; i < s.length(); i++) {
+            Character c = s.charAt(i);
+            charToFreq.compute(c, (k, v) -> v == null ? 1 : v + 1);
+        }
+
+        int res = 0;
+        for (Map.Entry<Character, Integer> kv: charToFreq.entrySet()) {
+            Character k = kv.getKey();
+            Integer v = kv.getValue();
+            if (res % 2 == 0) {
+                res += v;
+            } else {
+                if (v % 2 == 1) {
+                    v -= 1;
+                }
+                res += v;
+            }
+        }
+        return res;
+    }
+}
+
+// time O(n)
+// space O(1)
+// using hashmap and store sth’s freq

[C]hashmap/[C]hashmap/409-longest-palindrome.java

@@ -14,5 +14,5 @@ def longestPalindrome(self, s: str) -> int:
         return res
 
 # time O(n)
-# space O(n)
+# space O(1)
 # using hashmap and store sth’s freq

[C]hashmap/[C]hashmap/409-longest-palindrome.py

@@ -0,0 +1,48 @@
+class Solution {
+    public boolean backspaceCompare(String s, String t) {
+        int i = s.length() - 1;
+        int j = t.length() - 1;
+        int iBack = 0;
+        int jBack = 0;
+        while (i >= 0 || j >= 0) {
+            Character iChar = null;
+            Character jChar = null;
+            while (i >= 0) {
+                if (s.charAt(i) == '#') {
+                    iBack += 1;
+                    i -= 1;
+                }
+                else if (iBack > 0) {
+                    iBack -= 1;
+                    i -= 1;
+                } else {
+                    iChar = s.charAt(i);
+                    i -= 1;
+                    break;
+                }
+            }
+            while (j >= 0) {
+                if (t.charAt(j) == '#') {
+                    jBack += 1;
+                    j -= 1;
+                }
+                else if (jBack > 0) {
+                    jBack -= 1;
+                    j -= 1;
+                } else {
+                    jChar = t.charAt(j);
+                    j -= 1;
+                    break;
+                }
+            }
+            if (!Objects.equals(iChar, jChar)) {
+                return false;
+            }
+        }
+        return true;
+    }
+}
+
+// time O(n+m)
+// space O(1)
+// using string and traverse from end and two pointers

[F]string/[F]string/844-backspace-string-compare.java

@@ -0,0 +1,22 @@
+class Solution {
+  public boolean canAttendMeetings(int[][] intervals) {
+      if (intervals.length == 0) {
+          return true;
+      }
+      Arrays.sort(intervals, (a, b) -> a[0] == b[0] ? Integer.compare(a[1], b[1]) : Integer.compare(a[0], b[0]));
+      int prevE = intervals[0][1];
+      for (int i = 1; i < intervals.length; i++) {
+          int curS = intervals[i][0];
+          int curE = intervals[i][1];
+          if (prevE > curS) {
+              return false;
+          }
+          prevE = Math.max(prevE, curE);
+      }
+      return true;
+  }
+}
+
+// time O(nlogn)
+// space O(1), or consider sort's cost
+// using array and line sweep and compare two intervals each round

[H]array/[H]array-line-sweep/252-meeting-rooms.java

@@ -3,8 +3,8 @@ public boolean isPalindrome(String s) {
         int left = 0;
         int right = s.length() - 1;
         while (left < right) {
-            Character lc = s.charAt(left);
-            Character rc = s.charAt(right);
+            char lc = s.charAt(left);
+            char rc = s.charAt(right);
             if (!Character.isLetterOrDigit(lc)) {
                 left += 1;
             } else if (!Character.isLetterOrDigit(rc)) {

[H]array/[H]array-two-pointers-opposite-direction/125-valid-palindrome.java

@@ -0,0 +1,24 @@
+class Solution {
+    public int majorityElement(int[] nums) {
+        Integer cand = null;
+        int vote = 0;
+        for (int i = 0; i < nums.length; i++) {
+            if (cand != null && cand == nums[i]) {
+                vote += 1;
+            } else if (cand == null) {
+                cand = nums[i];
+                vote = 1;
+            } else {
+                vote -= 1;
+                if (vote == 0) {
+                    cand = null;
+                }
+            }
+        }
+        return cand;
+    }
+}
+
+// time O(n)
+// space O(1)
+// using array and boyer moore vote algorithm

[H]array/[H]array/169-majority-element.java

@@ -7,7 +7,7 @@ public boolean isValid(String s) {
         ArrayDeque<Character> stack = new ArrayDeque<>();
         for (Character c: s.toCharArray()) {
             if (closeOpen.containsKey(c)) {
-                if (!closeOpen.get(c).equals(stack.peek())) {
+                if (!Objects.equals(stack.peek(), closeOpen.get(c))) {
                     return false;
                 }
                 stack.pop();