力扣102：二叉树的层序遍历

二叉树的层序遍历

1.递归实现

-相同层次的节点归入同一个数组

-传入辅助的level参数决定层次

时间复杂度O（n）

空间复杂度O（n）

2.迭代

-关键词：层次遍历

-模式识别：一旦出现树的层次遍历，都可以用队列作为辅助结构

//二叉树的层序遍历
//递归 dfs
func levelOrder1(root *TreeNode) [][]int {
	ans := [][]int{}
	var f func(*TreeNode, int)
	f = func(r *TreeNode, i int) {
		if r != nil {
			if i == len(ans) {
				ans = append(ans, []int{})
			}
			ans[i] = append(ans[i], r.Val)
			f(r.Left, i+1)
			f(r.Right, i+1)
		}
	}
	f(root, 0)
	return ans
}

//宽搜队列 bfs
func levelOrder2(root *TreeNode) (ans [][]int) {
	if root == nil {
		return
	}
	queue := []*TreeNode{root}
	for level := 0; len(queue) > 0; level++ {
		vals := []int{}
		q := queue
		queue = nil
		for _, node := range q {
			vals = append(vals, node.Val)
			if node.Left != nil {
				queue = append(queue, node.Left)
			}
			if node.Right != nil {
				queue = append(queue, node.Right)
			}
		}
		ans = append(ans, vals)
	}
	return
}

func main() {
	tree := &TreeNode{Val: 3, Left: &TreeNode{Val: 9}, Right: &TreeNode{Val: 20}}
	n := levelOrder2(tree)
	fmt.Println(n)
}

//同样的103题，Z字形打印无非加一个奇数行打印的时候做个翻转，代码如下：
func levelOrder3(root *TreeNode) (ans [][]int) {
	if root == nil {
		return
	}
	queue := []*TreeNode{root}
	for level := 0; len(queue) > 0; level++ {
		vals := []int{}
		q := queue
		queue = nil
		for _, node := range q {
			vals = append(vals, node.Val)
			if node.Left != nil {
				queue = append(queue, node.Left)
			}
			if node.Right != nil {
				queue = append(queue, node.Right)
			}
		}
		// 本质上和层序遍历一样，我们只需要把奇数层的元素翻转即可
		if level%2 == 1 {
			for i, n := 0, len(vals); i < n/2; i++ {
				vals[i], vals[n-1-i] = vals[n-1-i], vals[i]
			}
		}
		ans = append(ans, vals)
	}
	return
}