[sonshn] WEEK 04 Solutions

climbing-stairs/sonshn.java

@@ -0,0 +1,20 @@
+/**
+ * dp[i] = dp[i - 1] + dp[i - 2]
+ */
+class Solution {
+    public int climbStairs(int n) {
+        if (n <= 2) {
+            return n;
+        }
+
+        int[] dp = new int[n + 1];
+        dp[1] = 1;
+        dp[2] = 2;
+
+        for (int i = 3; i <= n; i++) {
+            dp[i] = dp[i - 1] + dp[i - 2];
+        }
+
+        return dp[n];
+    }
+}

maximum-depth-of-binary-tree/sonshn.java

@@ -0,0 +1,57 @@
+/**
+ * 이진 트리의 최대 깊이를 재귀적으로 계산 (DFS)
+ * 
+ * 시간 복잡도: O(n), n은 트리의 노드 수
+ * 공간 복잡도: O(h), h는 트리의 높이, 재귀 호출로 인해 스택에 쌓이는 함수 호출의 깊이 때문
+ */
+class Solution {
+    public int maxDepth(TreeNode root) {
+        if (root == null) {
+            return 0;
+        }
+
+        int leftDepth = maxDepth(root.left);
+        int rightDepth = maxDepth(root.right);
+
+        return Math.max(leftDepth, rightDepth) + 1;
+    }
+}
+
+/**
+ * 이진 트리의 최대 깊이를 반복적으로 계산 (BFS)
+ * 
+ * 시간 복잡도: O(n), n은 트리의 노드 수
+ * 공간 복잡도: O(n), 큐에 저장되는 노드 수 때문
+ */
+class Solution {
+    public int maxDepth(TreeNode root) {
+        if (root == null) {
+            return 0;
+        }
+
+        Queue<TreeNode> queue = new LinkedList<>();
+        queue.offer(root);
+
+        int depth = 0;
+
+        while (!queue.isEmpty()) {
+            int size = queue.size();
+
+            for (int i = 0; i < size; i++) {
+                TreeNode current = queue.poll();
+
+                if (current.left != null) {
+                    queue.offer(current.left);
+                }
+
+                if (current.right != null) {
+                    queue.offer(current.right);
+                }
+            }
+
+            depth++;
+        }
+
+        return depth;
+    }
+}

merge-two-sorted-lists/sonshn.java

@@ -0,0 +1,20 @@
+/**
+ * 재귀를 사용하여 두 개의 정렬된 연결 리스트를 병합
+ * 
+ * 시간 복잡도: O(n + m), n은 list1의 길이, m은 list2의 길이
+ * 공간 복잡도: O(n + m), 재귀 호출로 인해 스택에 쌓이는 함수 호출의 깊이 때문
+ */
+class Solution {
+    public ListNode mergeTwoLists(ListNode list1, ListNode list2) {
+        if (list1 == null) return list2;
+        if (list2 == null) return list1;
+
+        if (list1.val <= list2.val) {
+            list1.next = mergeTwoLists(list1.next, list2);
+            return list1;
+        } else {
+            list2.next = mergeTwoLists(list1, list2.next);
+            return list2;
+        }
+    }
+}

number-of-1-bits/sonshn.java

@@ -0,0 +1,19 @@
+/**
+ * hammingWeight
+ * 정수 n의 이진수 표현에서 1의 개수를 반환
+ * 
+ * 시간 복잡도: O(1)
+ * 공간 복잡도: O(1)
+ */
+public class sonshn {
+    public int hammingWeight(int n) {
+        int count = 0;
+
+        while (n != 0) {
+            count += (n & 1);
+            n >>>= 1;
+        }
+
+        return count;
+    }
+}

valid-anagram/sonshn.java

@@ -0,0 +1,19 @@
+import java.util.*;
+
+/**
+ * String to char array, sort, and compare
+ * 
+ * 시간 복잡도: O(nlogn)
+ * 공간 복잡도: O(n)
+ */
+class Solution {
+    public boolean isAnagram(String s, String t) {
+        char[] sArray = s.toCharArray();
+        char[] tArray = t.toCharArray();
+
+        Arrays.sort(sArray);
+        Arrays.sort(tArray);
+
+        return Arrays.equals(sArray, tArray);
+    }
+}

valid-palindrome/sonshn.java

@@ -0,0 +1,36 @@
+/**
+ * Palindrome 문자열인지 확인하는 문제
+ * 
+ * Java에서 제공하는 Character.isLetterOrDigit() 메서드를 사용하여 알파벳과 숫자인지 확인하고,
+ * Character.toLowerCase() 메서드를 사용하여 대소문자를 구분하지 않고 비교
+ * 
+ * 시간 복잡도: O(n)
+ * 공간 복잡도: O(1)
+ */
+class Solution {
+    public boolean isPalindrome(String s) {
+        int left = 0;
+        int right = s.length() - 1;
+
+        while (left < right) {
+
+            while (left < right && !Character.isLetterOrDigit(s.charAt(left))) {
+                left++;
+            }
+
+            while (left < right && !Character.isLetterOrDigit(s.charAt(right))) {
+                right--;
+            }
+
+            if (Character.toLowerCase(s.charAt(left))
+                    != Character.toLowerCase(s.charAt(right))) {
+                return false;
+            }
+
+            left++;
+            right--;
+        }
+
+        return true;
+    }
+}