Merge pull request #2148 from chjung99/main

Author: chjung99

counting-bits/chjung99.java

@@ -0,0 +1,31 @@
+// time: O(n)
+// space: O(n)
+
+class Solution {
+    public int[] countBits(int n) {
+        int[] ans = new int[n+1];
+
+        if (n >= 1){
+            ans[0] = 0;
+            ans[1] = 1;
+        }
+        int fac = 2;
+        int prev = 1;
+
+        for (int i = 2; i <= n; i++){
+            if (i == fac){
+                prev = fac;
+                fac *= 2;
+
+                ans[i] = 1;
+                continue;
+            }
+
+            ans[i] = 1+ ans[i-prev];
+        }
+
+        return ans;
+    }
+}
+
+

longest-palindromic-substring/chjung99.java

@@ -0,0 +1,43 @@
+// brute force
+// time: O(N^3)
+// space: O(N)
+
+class Solution {
+    public String longestPalindrome(String s) {
+        String answer = "";
+        int maxLen = 0;
+        int sLen = s.length();
+
+        for (int i = 0; i < sLen; i++){
+            for (int j = i ; j < sLen; j++){
+                String substring = s.substring(i, j+1);
+                if (isPalindrom(substring) && maxLen < (j-i+1)){
+                    maxLen = (j-i+1);
+                    answer = substring;
+                }
+            }
+        }
+
+        return answer;
+    }
+
+    public boolean isPalindrom(String s){
+        int start = 0;
+        int end = s.length()-1;
+
+
+        while(start < end) {
+            if (s.charAt(start) == s.charAt(end)){
+                start++;
+                end--;
+            } else {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+}
+
+

longest-substring-without-repeating-characters/chjung99.java

@@ -0,0 +1,23 @@
+// two pointer
+// time: O(N)
+// space: O(N)
+class Solution {
+    public int lengthOfLongestSubstring(String s) {
+        int answer = 0;
+        Set<Character> charSet = new HashSet<>();
+        int head = 0;
+        int tail = 0;
+
+        for (int i = 0; i < s.length(); i++){
+            Character ch = Character.valueOf(s.charAt(i));
+            while (charSet.contains(ch)) {
+                charSet.remove(Character.valueOf(s.charAt(head++)));
+            }
+            charSet.add(ch);
+            tail += 1;
+            answer = Math.max(answer, charSet.size());
+        }
+        return answer;
+    }
+}
+

missing-number/chjung99.java

@@ -0,0 +1,17 @@
+// time: O(N)
+// space: O(1)
+
+class Solution {
+    public int missingNumber(int[] nums) {
+        int maxValue = 0;
+        int sum = 0;
+        for (int i = 0; i < nums.length; i++){
+            if (maxValue < nums[i]) maxValue = nums[i];
+            sum += nums[i];
+        }
+        int n = Math.max(nums.length, maxValue);
+
+        return (int) (n * (n + 1))/2 - sum;
+    }
+}
+

subtree-of-another-tree/chjung99.java

@@ -0,0 +1,70 @@
+// time: O(N^2)
+// space: O(N)
+
+/**
+ * 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 boolean isSubtree(TreeNode root, TreeNode subRoot) {
+        Deque<TreeNode> deque = new ArrayDeque<>();
+        deque.add(root);
+
+        while (!deque.isEmpty()){
+            TreeNode cur = deque.poll();
+
+            if (isEqual(cur, subRoot)) {
+                return true;
+            }
+
+            if (cur.left != null) deque.add(cur.left);
+            if (cur.right != null) deque.add(cur.right);
+        }
+        return false;
+    }
+
+    public boolean isEqual(TreeNode x, TreeNode y){
+        Deque<TreeNode> dequeX = new ArrayDeque<>();
+        Deque<TreeNode> dequeY = new ArrayDeque<>();
+
+        dequeX.add(x);
+        dequeY.add(y);
+
+        while (!dequeX.isEmpty()||!dequeY.isEmpty()){
+            TreeNode curX = dequeX.poll();
+            TreeNode curY = dequeY.poll();
+
+            if (curX.val != curY.val) return false;
+
+            if (curX.left != null && curY.left != null){
+                dequeX.add(curX.left);
+                dequeY.add(curY.left);
+            } else if (curX.left == null && curY.left == null){
+                ;
+            } else{
+                return false;
+            }
+            if (curX.right != null && curY.right != null){
+                dequeX.add(curX.right);
+                dequeY.add(curY.right);
+            } else if (curX.right == null && curY.right == null){
+                ;
+            } else{
+                return false;
+            }
+        }
+        return (dequeX.isEmpty() && dequeY.isEmpty());
+    }
+}
+