week 11

Author: obzva

graph-valid-tree/flynn.go

@@ -0,0 +1,57 @@
+/*
+풀이
+- valid tree인지 판별하는 문제입니다
+  주어진 input이 valid tree이려면,
+  1. cycle이 없어야 합니다 (cycle이 있는 경우: [[0, 1], [1, 2], [2, 0]])
+  2. 모든 node가 연결되어 있어야 합니다 (모든 node가 연결되지 않은 경우: [[0, 1], [2, 3]])
+- dfs 방식의 함수를 재귀 호출하여 풀이할 수 있습니다
+Big O
+- N: n
+- E: 주어진 배열 edges의 크기
+- Time complexity: O(N)
+  - 모든 node를 최대 1번씩 탐색합니다
+- Space complexity: O(E + N)
+  - visited의 크기는 N에 비례하여 증가합니다 -> O(N)
+  - adj의 크기는 E에 비례하여 증가합니다 -> O(E)
+  - dfs의 재귀호출 스택 깊이는 최악의 경우 N까지 커질 수 있습니다 -> O(N)
+*/
+
+func validTree(n int, edges [][]int) bool {
+	// valid tree는 n-1개의 edge를 가질 수 밖에 없습validTree
+	// 아래 판별식을 이용하면 유효하지 않은 input에 대해 상당한 연산을 줄일 수 있습니다
+	if len(edges) != n-1 {
+		return false
+	}
+	// 주어진 2차원 배열 edges를 이용해 adjacency list를 생성합니다
+	adj := make([][]int, n)
+	for _, edge := range edges {
+		adj[edge[0]] = append(adj[edge[0]], edge[1])
+		adj[edge[1]] = append(adj[edge[1]], edge[0])
+	}
+	// cycle이 있는지 여부를 판단하기 위해 visited라는 map을 생성합니다 (Go에서는 map으로 set 기능을 대신함)
+	visited := make(map[int]bool)
+
+	var dfs func(int, int) bool
+	dfs = func(node int, parent int) bool {
+		// cycle 발견시 false return
+		if _, ok := visited[node]; ok {
+			return false
+		}
+		visited[node] = true
+		for _, next := range adj[node] {
+			if next == parent {
+				continue
+			}
+			if !dfs(next, node) {
+				return false
+			}
+		}
+		return true
+	}
+	// cycle 여부를 판단합니다
+	if !dfs(0, -1) {
+		return false
+	}
+	// node가 모두 연결되어 있는지 여부를 판단합니다
+	return len(visited) == n
+}

maximum-depth-of-binary-tree/flynn.go

@@ -0,0 +1,83 @@
+/*
+풀이
+- DFS
+Big O
+- N: 노드의 개수
+- H: 트리의 높이
+- Time complexity: O(N)
+  - 모든 노드를 탐색합니다
+- Space complexity: O(H)
+  - 재귀호출 스택의 크기는 트리의 높이에 비례하여 증가합니다
+*/
+
+/**
+ * Definition for a binary tree node.
+ * type TreeNode struct {
+ *     Val int
+ *     Left *TreeNode
+ *     Right *TreeNode
+ * }
+ */
+ func maxDepth(root *TreeNode) int {
+	maxDepth := 0
+	var dig func(*TreeNode, int)
+	dig = func(node *TreeNode, depth int) {
+		if node == nil {
+			if maxDepth < depth {
+				maxDepth = depth
+			}
+			return
+		}
+		dig(node.Left, depth+1)
+		dig(node.Right, depth+1)
+	}
+	dig(root, 0)
+	return maxDepth
+}
+
+/*
+풀이
+- BFS
+Big O
+- N: 노드의 개수
+- Time complexity: O(N)
+  - 모든 노드를 탐색합니다
+- Space complexity: O(N)
+  - 노드 N개 짜리 트리에서 한 층의 폭은 N을 넘지 않습니다
+    따라서 queue의 공간복잡도는 O(N)입니다
+*/
+
+/**
+ * Definition for a binary tree node.
+ * type TreeNode struct {
+ *     Val int
+ *     Left *TreeNode
+ *     Right *TreeNode
+ * }
+ */
+func maxDepth(root *TreeNode) int {
+	level := 0
+	queue := make([]*TreeNode, 0)
+	if root != nil {
+		queue = append(queue, root)
+		level++
+	}
+	for len(queue) > 0 {
+		currQSize := len(queue)
+		for currQSize > 0 {
+			node := queue[0]
+			queue = queue[1:]
+			currQSize--
+			if node.Left != nil {
+				queue = append(queue, node.Left)
+			}
+			if node.Right != nil {
+				queue = append(queue, node.Right)
+			}
+		}
+		if len(queue) > 0 {
+			level++
+		}
+	}
+	return level
+}

reorder-list/flynn.go

@@ -0,0 +1,33 @@
+/**
+ * Definition for singly-linked list.
+ * type ListNode struct {
+ *     Val int
+ *     Next *ListNode
+ * }
+ */
+ func reorderList(head *ListNode) {
+	// find a middle node
+	slow, fast := head, head
+	for fast != nil && fast.Next != nil {
+		slow = slow.Next
+		fast = fast.Next.Next
+	}
+	// reverse the second part of the list
+	var prev, curr *ListNode = nil, slow
+	for curr != nil {
+		tmp := curr.Next
+		curr.Next = prev
+		prev = curr
+		curr = tmp
+	}
+	// merge two parts of the list
+	curr1, curr2 := head, prev
+	for curr2.Next != nil {
+		tmp := curr1.Next
+		curr1.Next = curr2
+		curr1 = tmp
+		tmp = curr2.Next
+		curr2.Next = curr1
+		curr2 = tmp
+	}
+}