二叉树层序遍历(go)

队列实现，基于这个层序遍历方式可以解决很多问题。

func levelOrder(root *TreeNode) [][]int{
    res := [][]int{}
    if root == nil {return res}
    for i := range res{
        res[i] = []int{}
    }
    queue := []*TreeNode{}
    cur := []int{}
    curEnd := root
    nextEnd := root
    queue = append(queue, curEnd) 
    for len(queue)!=0 {
        curNode := queue[0]
        queue = queue[1:]
        cur = append(cur, curNode.Val)        
        if curNode.Left!=nil{
            queue = append(queue, curNode.Left)
            nextEnd = curNode.Left
        }
        if curNode.Right!=nil{
            queue = append(queue, curNode.Right)
            nextEnd = curNode.Right
        }
        if curNode = curEnd {
            res = append(res, cur)
            curEnd, nextEnd = nextEnd, nil
            cur = []int{}//此时cur应该已经换了底层数据存储位置
        }
    }
    return res
}

实现思路

定义一个队列存储树节点
按题目顺序依次将树节点及其左右子节点存入队列 处理当前节点的同时需要判断这个节点是否是某一层末尾节点，用于做后续处理

基于此的题目

反转二叉树

func invertTree(root *TreeNode) *TreeNode{
    if root==nil{return root}
    queue := []*TreeNode{root}
    for len(queue)!=nil{
        curNode := queue[0]
        queue = queue[1:]
        curNode.Left, curNode.Right = curNode.Right, curNode.Left
        if curNode.Left != nil{
            queue = append(queue, curNode.Left)
        }
        if curNode.Right != nil {
            queue = append(queue, curNode.Right)
        }
    }
    return root
}

103. 二叉树的锯齿形层序遍历，层序遍历+reverse处理特定层序列

func zigzagLevelOrder(root *TreeNode) [][]int {
    res := [][]int{}
    if root == nil {return res}
    cur := []int{}
    tag := false
    queue := []*TreeNode{}
    queue = append(queue, root)
    curEnd, nextEnd := root, root
    for len(queue)!=0 {     
        curNode := queue[0]
        cur = append(cur, curNode.Val)
        queue = queue[1:]
        if curNode.Left!=nil {
            nextEnd = curNode.Left
            queue = append(queue, curNode.Left)
        }
        if curNode.Right!=nil {
            nextEnd = curNode.Right
            queue = append(queue, curNode.Right)
        }
        if curNode==curEnd{
            curEnd, nextEnd = nextEnd, nil
            if tag{
                reverse(cur)
            }
            tag = !tag
            res = append(res, cur)
            cur = []int{}
        }   
    }
    return res
}
func reverse(cur []int){
    left, right := 0, len(cur)-1
    for left<=right {
        cur[left], cur[right] = cur[right], cur[left]
        left++
        right--
    }
}