[TONY] WEEK 01 solutions

contains-duplicate/TonyKim9401.java

@@ -0,0 +1,17 @@
+class Solution {
+    public boolean containsDuplicate(int[] nums) {
+        // HashSet  O(n)
+        /*
+        Set<Integer> set = new HashSet();
+        for (int num : nums) set.add(num);
+        return set.size() != nums.length;
+        */
+
+        // dupl value O(n log n)
+        Arrays.sort(nums);
+        for (int i = 0; i < nums.length - 1; i++) {
+            if (nums[i] == nums[i + 1]) return true;
+        }
+        return false;
+    }
+}

kth-smallest-element-in-a-bst/TonyKim9401.java

@@ -0,0 +1,18 @@
+class Solution {
+    private List<Integer> nums = new ArrayList<>();
+    public int kthSmallest(TreeNode root, int k) {
+        visitTreeNode(root);
+        return nums.get(k-1);
+    }
+
+    public void visitTreeNode(TreeNode node) {
+        if (node == null) return;
+
+        // left < right
+        visitTreeNode(node.left);
+        nums.add(node.val);
+        visitTreeNode(node.right);
+    }
+    // time complexity: O(n), visit all nodes once
+    // space complexity: O(1), used an array list
+}

number-of-1-bits/TonyKim9401.java

@@ -0,0 +1,21 @@
+class Solution {
+    public int hammingWeight(int n) {
+        /*
+        Time complexity: O(n)
+        Space complexity: O(1)
+         */
+        return Integer.bitCount(n);
+
+        /*
+        Time complexity: O(n)
+        Space complexity: O(1)
+
+        int output = 0;
+        while (n > 0) {
+            if ((n & 1) == 1) output += 1;
+            n >>= 1;
+        }
+        return output;
+        */
+    }
+}

top-k-frequent-elements/TonyKim9401.java

@@ -0,0 +1,32 @@
+class Solution {
+    public int[] topKFrequent(int[] nums, int k) {
+
+        // declare hashmap 
+        // key: each element, value: appered count
+        Map<Integer, Integer> map = new HashMap<>();
+
+        // if map contains the element, increase its value by one.
+        // else put the element and 1 for initializing
+        for (int num : nums) {
+            if (map.containsKey(num)) {
+                map.put(num, map.getOrDefault(num, 0) + 1);
+            } else {
+                map.put(num, 1);
+            }
+        }
+
+        // keyList only has key values of the hashmap
+        // using their value count sort keys by descending order
+        List<Integer> keyList = new ArrayList<>(map.keySet());
+        Collections.sort(keyList, (o1, o2) -> map.get(o2).compareTo(map.get(o1)));
+
+
+        int[] output = new int[k];
+        int idx = 0;
+
+        // retreive keys k times and set output
+        while (idx < k) output[idx] = keyList.get(idx++);
+
+        return output;
+    }
+}