Merge pull request DaleStudy#132 from Invidam/week07-invidam

[Invidam] Week 7

Author: Invidam

binary-tree-level-order-traversal/invidam.go.md

@@ -0,0 +1,83 @@
+# Intuition
+<!-- Describe your first thoughts on how to solve this problem. -->
+트리를 순회하는 방법들 중, 레벨 순서대로 순회하는 방식을 알고있어 이를 이용했다.
+# Approach
+1. BFS를 진행한다.
+2. 진행하기 전, 해당 레벨에 몇개의 원소가 있는지(`currLen`)을 저장한다.
+3. 저장된 원소만큼 순회했다면, 레벨을 다 둘러본 것이므로 부가작업(`levels = append(levels, level)`)을 한다.
+
+# Complexity
+- Time complexity: $O(n)$
+  - 트리의 원소를 n개라고 했을 때, 모든 원소를 순회하는 비용 `O(n)`이 소모된다.
+- Space complexity: $O(n)$
+  - 트리의 원소를 n개라고 했을 때, 모든 원소들을 저장하는 배열이 `O(n)`을 소모한다.
+
+# Code
+```go
+func levelOrder(root *TreeNode) [][]int {
+	levels := make([][]int, 0)
+
+	if root == nil {
+		return levels
+	}
+
+	q := []*TreeNode{root}
+
+	for len(q) > 0 {
+		level := make([]int, 0)
+		currLen := len(q)
+		for i := 0; i < currLen; i++ {
+			front := q[0]
+			level = append(level, front.Val)
+			q = q[1:]
+
+			if front.Left != nil {
+				q = append(q, front.Left)
+			}
+			if front.Right != nil {
+				q = append(q, front.Right)
+			}
+		}
+		levels = append(levels, level)
+	}
+
+	return levels
+}
+
+```
+
+```go
+func levelOrder(root *TreeNode) [][]int {
+	levels := make([][]int, 0)
+
+	if root == nil {
+		return levels
+	}
+
+	q := []*TreeNode{root}
+	var nextQ []*TreeNode
+
+	for len(q) > 0 {
+		level := make([]int, 0)
+		for _, front := range q {
+			level = append(level, front.Val)
+
+			if front.Left != nil {
+				nextQ = append(nextQ, front.Left)
+			}
+			if front.Right != nil {
+				nextQ = append(nextQ, front.Right)
+			}
+		}
+		q, nextQ = nextQ, q[:0]
+
+		levels = append(levels, level)
+	}
+
+	return levels
+}
+
+```
+- 첫 번째 코드는 `q[1:]`을 이용해서 큐의 `pop()`을 구현한다. 하지만 GoLang에서는 `pop()`을 한다고해서, 참조가 해제되지 않아 메모리를 계속 잡아먹는다.
+  - `pop()`을 하더라도 `q`가 순회하는 모든 원소들을 참조하고 있다. 
+- 두 번째 코드는 `q, nextQ = nextQ, q[:0]`을 이용해서 `q`와 `nextQ`의 메모리 영역을 교체할 뿐, 부가적인 메모리 공간을 필요로 하지 않아 더욱 효율적이다. 

lowest-common-ancestor-of-a-binary-search-tree/invidam.go.md

@@ -0,0 +1,95 @@
+# Intuition
+이전에 풀어봤던 문제였다! 어려운 문제였다는 생각을 벗어던지고 최대한 간단하게 풀어보려고 했다.
+# Approach
+<!-- Describe your approach to solving the problem. -->
+1. 두 노드(`p`, `q`) 모두 어떠한 경로를 거쳐, 해당 노드까지 도착하는지 조상들을 배열(`routes`)에 저장한다.
+2. 배열을 하나씩 비교해가며, 두 노드가 엇갈리는 지점(`pRoutes[idx] != qRoutes[idx]`)을 찾는다.
+3. 그 지점 바로 이전 지점(`[idx-1]`)이 최소 공통 조상이다.
+# Complexity
+- Time complexity
+  - 평균: $O(log(n))$
+  - 최악: $O(n)$
+  - 트리의 높이만큼 순회를 하게된다. 노드가 n개 이므로, 트리의 높이는 최선 `log(n)`, 최악 `n`이 된다.
+
+- Space complexity
+    - 평균: $O(log(n))$
+    - 최악: $O(n)$
+    - 트리의 높이만큼 순회를 하게된다. 노드가 n개 이므로, 트리의 높이는 최선 `log(n)`, 최악 `n`이 된다.
+
+# Code
+```go
+func getRoutes(head, target *TreeNode) []*TreeNode {
+	routes := make([]*TreeNode, 0)
+
+	curr := head
+	for curr.Val != target.Val {
+		routes = append(routes, curr)
+		if target.Val == curr.Val {
+			break
+		} else if target.Val < curr.Val {
+			curr = curr.Left
+		} else {
+			curr = curr.Right
+		}
+	}
+	return append(routes, curr)
+}
+
+func lowestCommonAncestor(root, p, q *TreeNode) *TreeNode {
+	pRoutes := getRoutes(root, p)
+	qRoutes := getRoutes(root, q)
+
+	idx := 0
+	for idx < min(len(pRoutes), len(qRoutes)) && pRoutes[idx] == qRoutes[idx] {
+		idx++
+	}
+
+	return pRoutes[idx-1]
+}
+
+```
+# Intuition & Approach
+(솔루션의 해결법 참고)
+
+두 노드는 공통조상까지는 동일한 대소관계를 가지고 있다가, 공통 조상 이후로 대소관계가 구분된다.
+따라서, 루트에서 동일한 대소관계가 있는 조상까지 이동한다. (다시 말해, 대소 관계가 구분되는 특정 지점이 발생한다면 그 지점의 부모가 공통 조상이다.)
+# Complexity
+- Time complexity
+  - 평균: $O(log(n))$
+  - 최악: $O(n)$
+  - 트리의 높이만큼 순회를 하게된다. 노드가 n개 이므로, 트리의 높이는 최선 `log(n)`, 최악 `n`이 된다.
+
+- Space complexity: $O(1)$
+  - 별도 자료구조를 사용하지 않고, 링크드 리스트의 순회만이 존재한다.
+
+# Code
+## For-loop
+```go
+func lowestCommonAncestor(root, p, q *TreeNode) *TreeNode {
+	curr := root
+	for {
+		if p.Val < curr.Val && q.Val < curr.Val {
+			curr = curr.Left
+		} else if p.Val > curr.Val && q.Val > curr.Val {
+			curr = curr.Right
+		} else {
+			break
+		}
+	}
+	return curr
+}
+
+```
+## Recursion
+```go
+func lowestCommonAncestor(root, p, q *TreeNode) *TreeNode {
+	if p.Val < root.Val && q.Val < root.Val {
+		return lowestCommonAncestor(root.Left, p, q)
+	} else if p.Val > root.Val && q.Val > root.Val {
+		return lowestCommonAncestor(root.Right, p, q)
+	}
+	return root
+}
+
+```
+: 함수 콜스택이 트리의 높이만큼 증가하므로, 공간 복잡도가 O(n)까지 증가할 수 있다. (처음 해결법의 공간 복잡도처럼.) 

remove-nth-node-from-end-of-list/invidam.go.md

@@ -0,0 +1,68 @@
+# Intuition
+n번 째를 알기 위해 정보(몇 번째에 어떤 요소가 있는지)를 알아야 한다.
+# Approach
+1. 배열에 링크드 리스트 정보를 모두 넣는다.
+2. 맨 앞 요소를 제거해야하는 경우 (`len(nodes) == n`) 헤드의 다음을 반환한다.
+3. 뒤에서 `n`번째 요소(`len(nodes)-n`)의 앞과 뒤를 이어붙여 `n`번째 요소를 제거한다.
+# Complexity
+- Time complexity: $O(n)$
+  - 링크드 리스트의 길이 `n`에 대하여, 이를 순회하는 비용이 발생한다.
+- Space complexity: $O(n)$
+  - 링크드 리스트의 길이 `n`에 대하여, 배열의 크기 `n`이 발생한다.
+
+# Code
+## Array
+```go
+func removeNthFromEnd(head *ListNode, n int) *ListNode {
+	nodes := make([]*ListNode, 0, 100)
+
+	for curr := head; curr != nil; curr = curr.Next {
+		nodes = append(nodes, curr)
+	}
+
+	if len(nodes) == n {
+		return head.Next
+	}
+
+	nodes[len(nodes)-n-1].Next = nodes[len(nodes)-n].Next
+	return head
+}
+
+```
+# Intuition
+배열의 모든 원소를 저장할 필요는 없어 보였다. 공간 복잡도를 줄일 방법을 알아보았다.
+# Approach
+모든 원소가 아니라, `n`번째의 이전(`prev`), 이후 (`next`)만을 저장하게 하였다.
+# Complexity
+- Time complexity: $O(n)$
+    - 링크드 리스트의 길이 `n`에 대하여, 이를 순회하는 비용이 발생한다.
+- Space complexity: $O(1)$
+    - 2개의 요소만 유지하므로, `O(1)`이다.
+
+# Code
+## Two Pointer
+```go
+func removeNthFromEnd(head *ListNode, n int) *ListNode {
+	len := 0
+	for curr := head; curr != nil; curr = curr.Next {
+		len++
+	}
+
+	if len == n {
+		return head.Next
+	}
+
+	var prev, curr, next *ListNode
+	curr = head
+	next = head.Next
+	for i := 0; i+n < len; i++ {
+		prev = curr
+		curr = next
+		next = next.Next
+	}
+
+	prev.Next = next
+	return head
+}
+
+```

reorder-list/invidam.go.md

@@ -0,0 +1,74 @@
+# Intuition
+<!-- Describe your first thoughts on how to solve this problem. -->
+재귀함수를 이용한 풀이를 생각하였으나, 맨 뒤에 있는 요소가 2번째 까지 장거리 이동해야 하므로 맨 뒤를 `O(1)`에 접근하기 위한 방법(배열을 떠올림)이 필요할 것이다.
+<!-- Describe your approach to solving the problem. -->
+1. Deque안에 모든 노드들을 삽입한다. 
+    - 코드에서는 배열(`nodes`)와 두 인덱스(`i`, `j`)가 `Deque`의 역할을 대신한다.
+2. 맨 앞, 맨 뒤에서 하나씩을 뺀다. (`f`, `b`)
+3. 맨 앞 요소 뒤에 맨 뒤 요소를 넣는다. (`f` --> `b` -- (기존) `f.Next`)
+3. reorder이후 맨 마지막 요소에 `nil`을 추가해 종료 지점을 만든다.
+# Complexity
+- Time complexity: $O(n)$
+  - 링크드 리스트의 길이 `n`에 대하여, 링크드리스트 순회와 배열 순회 비용 `n`이 발생한다.
+- Space complexity: $O(n)$
+  - 링크드 리스트의 길이 `n`에 대하여, 배열(`nodes`) 생성에 비용 `n`이 발생한다.
+# Code
+## Two Pointer(Deque)
+```go
+func reorderListv1(head *ListNode) {
+	nodes := make([]*ListNode, 0, 25)
+	for curr := head; curr != nil; curr = curr.Next {
+		nodes = append(nodes, curr)
+	}
+
+	i, j := 0, len(nodes)-1
+	for i < j {
+		nodes[j].Next = nodes[i].Next
+		nodes[i].Next = nodes[j]
+
+		i++
+		j--
+	}
+	nodes[i].Next = nil
+}
+
+```
+
+## 다른 풀이
+: 솔루션을 보며 뒤쪽 절반을 `reverse()`하여 해결하는 솔루션이 더욱 직관적으로 느껴졌다.
+
+```go
+func reverse(node *ListNode) *ListNode {
+	var prev *ListNode
+	curr := node
+	for curr != nil {
+		next := curr.Next
+		curr.Next = prev
+		prev = curr
+
+		curr = next
+	}
+	return prev
+}
+
+func reorderList(head *ListNode) {
+	slow, fast := head, head
+	for fast != nil && fast.Next != nil {
+		fast = fast.Next.Next
+		slow = slow.Next
+	}
+
+	curr, rCurr := head, reverse(slow.Next)
+	slow.Next = nil
+	for curr != nil && rCurr != nil {
+		next, rNext := curr.Next, rCurr.Next
+
+		rCurr.Next = next
+		curr.Next = rCurr
+
+		curr, rCurr = next, rNext
+	}
+}
+
+```
+: 인덱스 조절하는 게 꽤나 어려워서 솔루션을 참고했다...