第二周作业#29

Week_02/id_29/LeetCode_001_29.go

@@ -0,0 +1,21 @@
+package leetcode
+
+func twoSum(nums []int, target int) []int {
+	// m store value and index
+	visited := make(map[int]int)
+
+	for currentIndex, v := range nums {
+		// 找對應的元素
+		counterPart := target - v
+
+		counterPartIndex, ok := visited[counterPart]
+		if ok {
+			// 在 map 找到直接回傳
+			return []int{counterPartIndex, currentIndex}
+		}
+		// 找不到就把自己加入到 map 裡面
+		visited[v] = currentIndex
+	}
+
+	return []int{-1, -1}
+}

Week_02/id_29/LeetCode_003_29.go

@@ -0,0 +1,24 @@
+package leetcode
+
+import "strings"
+
+func lengthOfLongestSubstring(s string) int {
+	maxLength := 0
+	right := 0
+	curr := ""
+
+	for right < len(s) {
+		char := string(s[right])
+		if !strings.Contains(curr, char) {
+			curr += char
+			if len(curr) > maxLength {
+				maxLength = len(curr)
+			}
+			right++
+		} else {
+			curr = curr[1:]
+		}
+	}
+
+	return maxLength
+}

Week_02/id_29/LeetCode_098_29.go

@@ -0,0 +1,17 @@
+package leetcode
+
+func isValidBST(root *TreeNode) bool {
+	return rec(root, nil, nil)
+}
+
+func rec(node *TreeNode, min, max *int) bool {
+	if node == nil {
+		return true
+	}
+
+	if min != nil && node.Val <= *min || max != nil && node.Val >= *max {
+		return false
+	}
+
+	return rec(node.Left, min, &node.Val) && rec(node.Right, &node.Val, max)
+}

Week_02/id_29/LeetCode_100_29.go

@@ -0,0 +1,21 @@
+package leetcode
+
+func isSymmetric(root *TreeNode) bool {
+	if root == nil {
+		return true
+	}
+
+	return ish(root.Left, root.Right)
+}
+
+func ish(l, r *TreeNode) bool {
+	if l == nil || r == nil {
+		return l == r
+	}
+
+	if l.Val != r.Val {
+		return false
+	}
+
+	return ish(l.Left, r.Right) && ish(l.Right, r.Left)
+}

Week_02/id_29/LeetCode_102_29.go

@@ -0,0 +1,25 @@
+package leetcode
+
+func levelOrder(root *TreeNode) [][]int {
+	var ret [][]int
+
+	level := 1
+	helper(root, level, &ret)
+
+	return ret
+}
+
+func helper(root *TreeNode, level int, ret *[][]int) {
+	if root == nil {
+		return
+	}
+
+	if len(*ret) < level {
+		*ret = append(*ret, []int{root.Val})
+	} else {
+		(*ret)[level-1] = append((*ret)[level-1], root.Val)
+	}
+
+	helper(root.Left, level+1, ret)
+	helper(root.Right, level+1, ret)
+}

Week_02/id_29/LeetCode_103_29.go

@@ -0,0 +1,32 @@
+package leetcode
+
+func zigzagLevelOrder(root *TreeNode) [][]int {
+	var result [][]int
+
+	vector := 1
+	stack := []*TreeNode{root}
+
+	for len(stack) > 0 {
+		var tmp []*TreeNode
+		var levelVal []int
+		for i := len(stack) - 1; i >= 0; i-- {
+			node := stack[i]
+			if node == nil {
+				continue
+			}
+			if vector == 1 {
+				tmp = append(tmp, node.Left, node.Right)
+			} else {
+				tmp = append(tmp, node.Right, node.Left)
+			}
+			levelVal = append(levelVal, node.Val)
+		}
+		vector = -vector
+		stack = tmp
+		if len(levelVal) > 0 {
+			result = append(result, levelVal)
+		}
+	}
+
+	return result
+}

Week_02/id_29/LeetCode_111_29.go

@@ -0,0 +1,29 @@
+package leetcode
+
+func minDepth(root *TreeNode) int {
+	if root == nil {
+		return 0
+	}
+	left := minDepth(root.Left)
+	right := minDepth(root.Right)
+	if left == 0 || right == 0 {
+		return 1 + max(left, right)
+	}
+	return 1 + min(left, right)
+}
+
+func min(x, y int) int {
+	if x >= y {
+		return y
+	} else {
+		return x
+	}
+}
+
+func max(x, y int) int {
+	if x <= y {
+		return y
+	} else {
+		return x
+	}
+}

Week_02/id_29/LeetCode_236_29.go

@@ -0,0 +1,19 @@
+package leetcode
+
+func lowestCommonAncestor(root, p, q *TreeNode) *TreeNode {
+	if root == nil {
+		return nil
+	}
+	if root == p || root == q {
+		return root
+	}
+	left := lowestCommonAncestor(root.Left, p, q)
+	right := lowestCommonAncestor(root.Right, p, q)
+	if left != nil && right != nil {
+		return root
+	}
+	if left == nil {
+		return right
+	}
+	return left
+}

Week_02/id_29/LeetCode_242_29.go

@@ -0,0 +1,36 @@
+package leetcode
+
+func isAnagram(s string, t string) bool {
+	if len(s) != len(t) {
+		return false
+	}
+
+	mapA := buildCharMap(s)
+	mapB := buildCharMap(t)
+
+	for key, Acount := range mapA {
+		Bcount, ok := mapB[key]
+		if !ok {
+			return false
+		}
+		if Acount != Bcount {
+			return false
+		}
+	}
+
+	return true
+}
+
+func buildCharMap(s string) map[rune]int {
+	m := make(map[rune]int)
+
+	for _, char := range s {
+		if _, ok := m[char]; ok {
+			m[char]++
+		} else {
+			m[char] = 1
+		}
+	}
+
+	return m
+}

Week_02/id_29/LeetCode_692_29.go

@@ -0,0 +1,39 @@
+package leetcode
+
+import "sort"
+
+type entry struct {
+	word      string
+	frequence int
+}
+
+type freWords []*entry
+
+func topKFrequent(words []string, k int) []string {
+	count := make(map[string]int, len(words))
+	for _, w := range words {
+		count[w]++
+	}
+
+	fw := make(freWords, 0, len(count))
+	for w, c := range count {
+		fw = append(fw, &entry{
+			word:      w,
+			frequence: c,
+		})
+	}
+
+	sort.Slice(fw, func(i, j int) bool {
+		if fw[i].frequence == fw[j].frequence {
+			return fw[i].word < fw[j].word
+		}
+		return fw[i].frequence > fw[j].frequence
+	})
+
+	res := make([]string, k)
+	for i := 0; i < k; i++ {
+		res[i] = fw[i].word
+	}
+
+	return res
+}

Week_02/id_29/LeetCode_938_29.go

@@ -0,0 +1,22 @@
+package leetcode
+
+func rangeSumBST(root *TreeNode, L int, R int) int {
+	if root == nil {
+		return 0
+	}
+
+	sum := 0
+
+	switch {
+	case root.Val < L:
+		sum = rangeSumBST(root.Right, L, R)
+	case R < root.Val:
+		sum = rangeSumBST(root.Left, L, R)
+	default:
+		sum += root.Val
+		sum += rangeSumBST(root.Left, L, R)
+		sum += rangeSumBST(root.Right, L, R)
+	}
+
+	return sum
+}

Week_02/id_29/main.go

@@ -0,0 +1,12 @@
+package leetcode
+
+type ListNode struct {
+	Val  int
+	Next *ListNode
+}
+
+type TreeNode struct {
+	Val   int
+	Left  *TreeNode
+	Right *TreeNode
+}