u

AGENTS.md

@@ -0,0 +1,2 @@
+这是 leetcode 题练习 repo。
+第一层目录为题集名称，第二层目录为题号。

top-100-liked/41/leetcode_test.go

@@ -0,0 +1,35 @@
+package top100liked
+
+// https://leetcode.cn/problems/binary-tree-level-order-traversal/?envType=study-plan-v2&envId=top-100-liked
+
+type TreeNode struct {
+	Val   int
+	Left  *TreeNode
+	Right *TreeNode
+}
+
+func levelOrder(root *TreeNode) [][]int {
+	if root == nil {
+		return [][]int{}
+	}
+
+	queue := []*TreeNode{root}
+	res := [][]int{}
+	for len(queue) > 0 {
+		currentLayerRes := []int{}
+		tmpQueue := []*TreeNode{}
+		for i := range queue {
+			currentNode := queue[i]
+			currentLayerRes = append(currentLayerRes, currentNode.Val)
+			if currentNode.Left != nil {
+				tmpQueue = append(tmpQueue, currentNode.Left)
+			}
+			if currentNode.Right != nil {
+				tmpQueue = append(tmpQueue, currentNode.Right)
+			}
+		}
+		queue = tmpQueue
+		res = append(res, currentLayerRes)
+	}
+	return res
+}

top-100-liked/42/leetcode_test.go

@@ -0,0 +1,27 @@
+package top100liked
+
+// https://leetcode.cn/problems/convert-sorted-array-to-binary-search-tree/description/?envType=study-plan-v2&envId=top-100-liked
+
+type TreeNode struct {
+	Val   int
+	Left  *TreeNode
+	Right *TreeNode
+}
+
+func sortedArrayToBST(nums []int) *TreeNode {
+	if len(nums) == 0 {
+		return nil
+	}
+	if len(nums) == 1 {
+		return &TreeNode{Val: nums[0]}
+	}
+	if len(nums) == 2 {
+		return &TreeNode{Val: nums[1], Left: &TreeNode{Val: nums[0]}}
+	}
+	rootIdx := len(nums) / 2
+	rootVal := nums[rootIdx]
+	root := &TreeNode{Val: rootVal}
+	root.Left = sortedArrayToBST(nums[:rootIdx])
+	root.Right = sortedArrayToBST(nums[rootIdx+1:])
+	return root
+}

top-100-liked/43/leetcode_test.go

@@ -0,0 +1,66 @@
+package top100liked
+
+// https://leetcode.cn/problems/validate-binary-search-tree/description/?envType=study-plan-v2&envId=top-100-liked
+
+type TreeNode struct {
+	Val   int
+	Left  *TreeNode
+	Right *TreeNode
+}
+
+// AC, 但很慢
+// func inorderTraversal(root *TreeNode) []int {
+// 	if root == nil {
+// 		return []int{}
+// 	}
+// 	res := []int{}
+// 	if root.Left != nil {
+// 		res = append(res, inorderTraversal(root.Left)...)
+// 	}
+// 	res = append(res, root.Val)
+// 	if root.Right != nil {
+// 		res = append(res, inorderTraversal(root.Right)...)
+// 	}
+// 	return res
+// }
+
+// func isValidBST(root *TreeNode) bool {
+// 	if root == nil {
+// 		return true
+// 	}
+// 	l := inorderTraversal(root)
+// 	if len(l) == 1 {
+// 		return true
+// 	}
+// 	for i, j := 0, 1; j < len(l); {
+// 		if l[i] >= l[j] {
+// 			return false
+// 		}
+
+// 		i++
+// 		j++
+// 	}
+// 	return true
+// }
+
+func isValidBST(root *TreeNode) bool {
+	var prev *int
+	var inorder func(node *TreeNode) bool
+	inorder = func(node *TreeNode) bool {
+		if node == nil {
+			return true
+		}
+		if !inorder(node.Left) {
+			return false
+		}
+		if prev != nil && *prev >= node.Val {
+			return false
+		}
+		prev = &node.Val
+		if !inorder(node.Right) {
+			return false
+		}
+		return true
+	}
+	return inorder(root)
+}

top-100-liked/44/leetcode_test.go

@@ -0,0 +1,30 @@
+package top100liked
+
+// https://leetcode.cn/problems/kth-smallest-element-in-a-bst/description/?envType=study-plan-v2&envId=top-100-liked
+
+type TreeNode struct {
+	Val   int
+	Left  *TreeNode
+	Right *TreeNode
+}
+
+func kthSmallest(root *TreeNode, k int) int {
+	res, cnt := 0, 0
+	var helper func(node *TreeNode) bool
+	helper = func(node *TreeNode) bool {
+		if node == nil {
+			return false
+		}
+		if helper(node.Left) {
+			return true
+		}
+		cnt++
+		if cnt == k {
+			res = node.Val
+			return true
+		}
+		return helper(node.Right)
+	}
+	helper(root)
+	return res
+}

top-100-liked/45/leetcode_test.go

@@ -0,0 +1,33 @@
+package top100liked
+
+// https://leetcode.cn/problems/binary-tree-right-side-view/description/?envType=study-plan-v2&envId=top-100-liked
+
+type TreeNode struct {
+	Val   int
+	Left  *TreeNode
+	Right *TreeNode
+}
+
+func rightSideView(root *TreeNode) []int {
+	if root == nil {
+		return []int{}
+	}
+	queue := []*TreeNode{root}
+	res := []int{}
+	for len(queue) > 0 {
+		tmpQueue := []*TreeNode{}
+		for i := range queue {
+			if i == len(queue)-1 {
+				res = append(res, queue[i].Val)
+			}
+			if queue[i].Left != nil {
+				tmpQueue = append(tmpQueue, queue[i].Left)
+			}
+			if queue[i].Right != nil {
+				tmpQueue = append(tmpQueue, queue[i].Right)
+			}
+		}
+		queue = tmpQueue
+	}
+	return res
+}

top-100-liked/46/leetcode_test.go

@@ -0,0 +1,25 @@
+package top100liked
+
+// https://leetcode.cn/problems/flatten-binary-tree-to-linked-list/description/?envType=study-plan-v2&envId=top-100-liked
+
+type TreeNode struct {
+	Val   int
+	Left  *TreeNode
+	Right *TreeNode
+}
+
+func flatten(root *TreeNode) {
+	var prev *TreeNode
+	var helper func(*TreeNode)
+	helper = func(node *TreeNode) {
+		if node == nil {
+			return
+		}
+		helper(node.Right)
+		helper(node.Left)
+		node.Right = prev
+		node.Left = nil
+		prev = node
+	}
+	helper(root)
+}