Merge pull request #2117 from chjung99/main

Author: chjung99

contains-duplicate/chjung99.java

@@ -0,0 +1,20 @@
+/**
+ * time: O(n)
+ * space: O(n)
+ */
+
+import java.util.*;
+
+class Solution {
+    public boolean containsDuplicate(int[] nums) {
+        Set<Integer> hash = new HashSet<>();
+
+        for (int num: nums){
+            if (hash.contains(num)) return true;
+            hash.add(num);
+        }
+
+        return false;
+    }
+}
+

invert-binary-tree/chjung99.java

@@ -0,0 +1,50 @@
+/**
+ * time: O(n)
+ * space: O(n)
+ */
+
+import java.util.*;
+
+/**
+ * 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 TreeNode invertTree(TreeNode root) {
+        breadthFirstSearch(root);
+        return root;
+    }
+    public void breadthFirstSearch(TreeNode node){
+        Deque<TreeNode> queue = new ArrayDeque<>();
+        if (node != null){
+            queue.add(node);
+        }
+
+        while (!queue.isEmpty()){
+            TreeNode cur = queue.remove();
+
+            TreeNode tmp = cur.left;
+            cur.left = cur.right;
+            cur.right = tmp;
+
+            if (cur.left != null){
+                queue.add(cur.left);
+            }
+            if (cur.right != null){
+                queue.add(cur.right);
+            }
+        }
+    }
+}
+

number-of-1-bits/chjung99.java

@@ -0,0 +1,15 @@
+/**
+ * time: O(log n)
+ * space: O(1)
+ */
+class Solution {
+    public int hammingWeight(int n) {
+        int cnt = 0;
+        while (n != 0){
+            if (n % 2 == 1) cnt ++;
+            n = (int) (n/2);
+        }
+        return cnt;
+    }
+}
+

reverse-linked-list/chjung99.java

@@ -0,0 +1,39 @@
+/**
+ * time: O(n)
+ * space: O(1)
+ */
+
+/**
+ * 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 {
+    ListNode tail;
+    public ListNode reverseList(ListNode head) {
+        reverseNode(head);
+        return tail;
+    }
+
+    public void reverseNode(ListNode node){
+        if (node == null) return;
+        if (node.next == null) {
+            tail = node;
+            return;
+        }
+
+        ListNode nextNode = node.next;
+        node.next = null;
+
+        reverseNode(nextNode);
+
+        nextNode.next = node;
+
+    }
+}
+

valid-anagram/chjung99.java

@@ -0,0 +1,24 @@
+/**
+ * time: O(n)
+ * space: O(1)
+ */
+
+class Solution {
+    public boolean isAnagram(String s, String t) {
+        int[] countS = new int[26];
+        int slen = s.length();
+        int tlen = t.length();
+
+        if (slen != tlen) return false;
+
+        for (int i = 0; i < slen; i++){
+            countS[s.charAt(i)-'a'] += 1;
+            countS[t.charAt(i)-'a'] -= 1;
+        }
+        for (int i = 0; i < 26; i++){
+            if (countS[i] != 0) return false;
+        }
+        return true;
+    }
+}
+