[juhui-jeong] WEEK 13 Solutions

insert-interval/juhui-jeong.java

@@ -0,0 +1,38 @@
+/**
+ * 시간 복잡도: O(n)
+ * 공간 복잡도: O(n)
+ */
+class Solution {
+    public int[][] insert(int[][] intervals, int[] newInterval) {
+        List<int[]> result = new ArrayList<>();
+
+        int newStart = newInterval[0];
+        int newEnd = newInterval[1];
+        boolean inserted = false;
+
+        for (int i = 0; i < intervals.length; i++) {
+            int curStart = intervals[i][0];
+            int curEnd = intervals[i][1];
+
+            if (curEnd < newStart) {
+                // 1. newInterval 보다 왼쪽
+                result.add(new int[]{curStart, curEnd});
+            } else if (curStart > newEnd) {
+                // 2. newInterval 보다 오른쪽
+                if (!inserted) {
+                    result.add(new int[]{newStart, newEnd});
+                    inserted = true;
+                }
+                result.add(new int[]{curStart, curEnd});
+            } else {
+                newStart = Math.min(newStart, curStart);
+                newEnd = Math.max(newEnd, curEnd);
+            }
+        }
+
+        if (!inserted) {
+            result.add(new int[]{newStart, newEnd});
+        }
+        return result.toArray(new int[result.size()][]);
+    }
+}

kth-smallest-element-in-a-bst/juhui-jeong.java

@@ -0,0 +1,19 @@
+/**
+ * 시간 복잡도: O(n)
+ * 공간 복잡도: O(n)
+ */
+class Solution {
+    public int kthSmallest(TreeNode root, int k) {
+        List<Integer> list = new ArrayList<>();
+        inorder(root, list);
+
+        return list.get(k-1);
+    }
+    private void inorder(TreeNode node, List<Integer>list) {
+        if (node == null) return;
+
+        inorder(node.left, list);
+        list.add(node.val);
+        inorder(node.right, list);
+    }
+}

lowest-common-ancestor-of-a-binary-search-tree/juhui-jeong.java

@@ -1,7 +1,8 @@
 /*
+    이전 풀이(반복문)
     시간복잡도: O(log N)
     공간복잡도: O(1)
- */
+
 class Solution {
     public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
         while(root != null) {
@@ -16,3 +17,19 @@ public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
         return null;
     }
 }
+ */
+
+/**
+    시간복잡도: O(h)
+    공간복잡도: O(h)
+ */
+class Solution {
+    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
+        if (p.val < root.val && q.val < root.val) {
+            return this.lowestCommonAncestor(root.left, p, q);
+        } else if (p.val > root.val && q.val > root.val) {
+            return this.lowestCommonAncestor(root.right, p, q);
+        }
+        return root;
+    }
+}

non-overlapping-intervals/juhui-jeong.java

@@ -1,51 +1,79 @@
 /*
- * 끝나는 시간 오름차순 정렬
- */
+처음 풀이
+시작 시간 기준 정렬
 class Solution {
     public int eraseOverlapIntervals(int[][] intervals) {
-        Arrays.sort(intervals, (a,b) -> Integer.compare(a[1], b[1]));
+        Arrays.sort(intervals, (a,b) -> {
+            if (a[0] != b[0]) return Integer.compare(a[0], b[0]);
+            return Integer.compare(a[1], b[1]);
+        });
 
         int removeCntResult = 0;
-        int end = intervals[0][1];
+        int[] cur = intervals[0];
 
         for (int i = 1; i< intervals.length; i++) {
-            if (intervals[i][0] < end) {
+            int [] next = intervals[i];
+
+            if (cur[1] > next[0]) {
                 removeCntResult += 1;
+                if (next[1] < cur[1]) {
+                    cur = next;
+                }
             } else {
-                end = intervals[i][1];
+                cur = next;
             }
         }
         return removeCntResult;
     }
 }
+ */
 
 
 /*
-처음 풀이
-시작 시간 기준 정렬
+ * 끝나는 시간 오름차순 정렬
+
 class Solution {
     public int eraseOverlapIntervals(int[][] intervals) {
-        Arrays.sort(intervals, (a,b) -> {
-            if (a[0] != b[0]) return Integer.compare(a[0], b[0]);
-            return Integer.compare(a[1], b[1]);
-        });
+        Arrays.sort(intervals, (a,b) -> Integer.compare(a[1], b[1]));
 
         int removeCntResult = 0;
-        int[] cur = intervals[0];
+        int end = intervals[0][1];
 
         for (int i = 1; i< intervals.length; i++) {
-            int [] next = intervals[i];
-
-            if (cur[1] > next[0]) {
+            if (intervals[i][0] < end) {
                 removeCntResult += 1;
-                if (next[1] < cur[1]) {
-                    cur = next;
-                }
             } else {
-                cur = next;
+                end = intervals[i][1];
             }
         }
         return removeCntResult;
     }
 }
  */
+
+/**
+ * 시간 복잡도: O(n log n)
+ * 공간 복잡도: O(n)
+ */
+class Solution {
+    public int eraseOverlapIntervals(int[][] intervals) {
+        Arrays.sort(intervals, (a,b) -> a[0] - b[0]);
+        int count = 0;
+        int prevEnd = intervals[0][1];
+
+        for (int i = 1; i < intervals.length; i++) {
+            int curStart = intervals[i][0];
+            int curEnd = intervals[i][1];
+
+            if (prevEnd <= curStart) {
+                // 안겹치는 경우(변경 없이 다음 배열로)
+                prevEnd = curEnd;
+            } else {
+                // 겹치는 경우
+                count++;
+                prevEnd = Math.min(prevEnd, curEnd);
+            }
+        }
+        return count;
+    }
+}

remove-nth-node-from-end-of-list/juhui-jeong.java

@@ -1,7 +1,32 @@
+
+/* 
+첫 번째 풀이
+class Solution {
+    public ListNode removeNthFromEnd(ListNode head, int n) {
+        List<ListNode> list = new ArrayList<>();
+
+        while(head != null) {
+            list.add(head);
+            head = head.next;
+        }
+
+        list.remove(list.size()-n);
+        if (list.isEmpty()) return null;
+
+        for (int i = 0; i < list.size()-1; i++) {
+            list.get(i).next = list.get(i+1);
+        }
+        list.get(list.size()-1).next = null;
+        return list.get(0);
+    }
+}
+*/
+
+
 /* 
 시간 복잡도: O(N)
 공간 복잡도: O(1)
-*/
+
 class Solution {
     public ListNode removeNthFromEnd(ListNode head, int n) {
         ListNode dummy = new ListNode(0);
@@ -24,26 +49,32 @@ public ListNode removeNthFromEnd(ListNode head, int n) {
         return dummy.next;
     }
 }
+*/
 
-/* 
-첫 번째 풀이
+/**
+ * 
+ * 시간 복잡도는 O(n)
+ * 공간 복잡도는 O(1)
+ */
 class Solution {
     public ListNode removeNthFromEnd(ListNode head, int n) {
-        List<ListNode> list = new ArrayList<>();
-
-        while(head != null) {
-            list.add(head);
-            head = head.next;
+        int length = 0;
+        ListNode curLenCheck = head;
+
+        while(curLenCheck != null) {
+            length++;
+            curLenCheck = curLenCheck.next;
         }
 
-        list.remove(list.size()-n);
-        if (list.isEmpty()) return null;
+        int targetIndex = length - n;
+        if (targetIndex == 0) return head.next;
 
-        for (int i = 0; i < list.size()-1; i++) {
-            list.get(i).next = list.get(i+1);
+        ListNode targetPrev = head;
+        for (int i=0; i < targetIndex-1; i++) {
+            targetPrev = targetPrev.next;
         }
-        list.get(list.size()-1).next = null;
-        return list.get(0);
+        targetPrev.next = targetPrev.next.next;
+
+        return head;
     }
 }
-*/

same-tree/juhui-jeong.java

@@ -10,3 +10,33 @@ public boolean isSameTree(TreeNode p, TreeNode q) {
         return isSameTree(p.left, q.left) && isSameTree(p.right, q.right);
     }
 }
+
+/*
+ * 시간 복잡도: O(n)
+ * 공간 복잡도: O(n)
+ */
+class Solution {
+    public boolean isSameTree(TreeNode p, TreeNode q) {
+        Queue<TreeNode> queueP = new LinkedList<>();
+        Queue<TreeNode> queueQ = new LinkedList<>();
+
+        queueP.offer(p);
+        queueQ.offer(q);
+
+        while(!queueP.isEmpty() && !queueQ.isEmpty()) {
+            TreeNode curP = queueP.poll();
+            TreeNode curQ = queueQ.poll();
+
+            if (curP == null && curQ == null) continue;
+            if (curP == null || curQ == null) return false;
+
+            if (curP.val != curQ.val) return false;
+
+            queueP.offer(curP.left);
+            queueQ.offer(curQ.left);
+            queueP.offer(curP.right);
+            queueQ.offer(curQ.right);            
+        }
+        return true;
+    }
+}

serialize-and-deserialize-binary-tree/juhui-jeong.java

@@ -0,0 +1,43 @@
+
+public class Codec {
+    private int index;
+
+    // Encodes a tree to a single string.(직렬화)
+    public String serialize(TreeNode root) {
+        StringBuilder sb = new StringBuilder();
+        dfsSerialize(root, sb);
+        return sb.toString();
+    }
+
+    private void dfsSerialize(TreeNode node, StringBuilder sb) {
+        if (node == null) {
+            sb.append("null").append(",");
+            return;
+        }
+        sb.append(node.val).append(",");
+
+        dfsSerialize(node.left, sb);
+        dfsSerialize(node.right, sb);        
+    }
+
+    // Decodes your encoded data to tree.(역직렬화)
+    public TreeNode deserialize(String data) {
+        String[] arr = data.split(",");
+        index = 0;
+        return dfsDeserialize(arr);
+    }
+
+    private TreeNode dfsDeserialize(String[] arr) {
+        String value = arr[index++];
+
+        if (value.equals("null")) {
+            return null;
+        }
+
+        TreeNode node = new TreeNode(Integer.parseInt(value));
+
+        node.left = dfsDeserialize(arr);
+        node.right = dfsDeserialize(arr);
+        return node;
+    }
+}