[hyeri0903] WEEK 13 Solutions

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

@@ -0,0 +1,48 @@
+/**
+ * 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 {
+    private int count = 0;
+    private int answer = 0;
+    public int kthSmallest(TreeNode root, int k) {
+        /**
+        1.BST에서 K번째 가장 작은 값 찾기
+        2.constraints : node 개수 ㅡin = 0, max = 10000
+        3.solutions:
+        - k번째 방문한 노드가 k번째로 작은 값 (bst 이므로)
+        - dfs search (inorder traversal)
+         */
+
+         dfs(root, k);
+         return answer;
+    }
+    private void dfs(TreeNode node, int k) {
+        if(node == null) {
+            return;
+        }
+
+
+        dfs(node.left, k);
+        count++;
+
+        if(count == k) {
+            answer = node.val;
+            return;
+        }
+
+        dfs(node.right, k);
+    }
+
+}

non-overlapping-intervals/hyeri0903.java

@@ -0,0 +1,30 @@
+class Solution {
+    public int eraseOverlapIntervals(int[][] intervals) {
+        /**
+        1.prob: 겹치지 않는 최소한의 non-oerlapping interval 제거
+        2.constraints
+        - inverval.lenght min=1, max = 100,000
+        3.solutions - Greedy
+        - end 기준 오름차순 정렬
+        - 이전 interval end 저장
+        - 다음 interval check, 안겹치면 -> 선택, 겹치면 count++
+        Time: O(n logn), Space: O(1)
+         */
+         int count = 0;
+
+         //end 기준 ascending 정렬
+         Arrays.sort(intervals, (a, b) -> a[1] - b[1]);
+          int end = intervals[0][1];
+
+         //겹치면 count++, 안겹치면 end update
+         for(int i = 1; i < intervals.length; i++) {
+                if(intervals[i][0] < end) {
+                    count++;
+                } else {
+                    end = intervals[i][1];
+                }
+         }
+
+        return count;
+    }
+}

remove-nth-node-from-end-of-list/hyeri0903.java

@@ -0,0 +1,46 @@
+/**
+ * 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 {
+    public ListNode removeNthFromEnd(ListNode head, int n) {
+        /**
+        1.linked list 에서 뒤에서 n번째 node remove
+        2.constraints:
+        node 개수(sz) min=1, max=30
+        n값  min = 1, max= sz
+        3.solutions: two pointers
+        - fast, slow pointer 2개의 간격 = n
+        - fast 가 끝지점에 도달하면 그때 slow.next 를 제거
+        time: O(n), space: O(1)
+         */
+
+         ListNode dummy = new ListNode(0);
+         dummy.next = head;
+
+         ListNode fast = dummy;
+         ListNode slow = dummy;
+
+         //fast pointer n+1칸 이동, fast - slow = n
+         for(int i = 0; i <= n; i++) {
+            fast = fast.next; 
+         }
+
+         while(fast != null) {
+            fast = fast.next;
+            slow = slow.next;
+         }
+
+         //slow pointer 의 다음 노드(slow.next) 제거
+         slow.next = slow.next.next;
+
+         return dummy.next;
+
+    }
+}

same-tree/hyeri0903.java

@@ -0,0 +1,44 @@
+/**
+ * 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 isSameTree(TreeNode p, TreeNode q) {
+        /**
+        1.problem: 2개의 bst 가 동일한지 체크
+        2.constraints - 구조와 노드가 동일해야된다
+        3.solution - DFS
+        1) 두 트리의 노드가 모두 null -> true
+        2) 둘중 하나만 null -> false
+        3) 값이 다르면 false
+        4)재귀로 트리의 구조가 동일한지 체크
+         */
+
+         if(p == null && q == null) {
+            return true;
+         }
+         if(p == null || q == null) {
+            return false;
+         }
+        if(p.val != q.val) {
+            return false;
+        }
+
+        if(isSameTree(p.left, q.left) && isSameTree(p.right, q.right)) {
+            return true;
+        }
+        return false;
+    }
+
+}