【LeetCode】103. 二叉树的锯齿形层次遍历

一、题目描述

给定一个二叉树，返回其节点值的锯齿形层次遍历。（即先从左往右，再从右往左进行下一层遍历，以此类推，层与层之间交替进行）。

例如：

给定二叉树 [3,9,20,null,null,15,7],

    3
   / \
  9  20
    /  \
   15   7

返回锯齿形层次遍历如下：

[
  [3],
  [20,9],
  [15,7]
]

二、解题思路 & 代码

2.1 DFS (空间复杂度：$O(lo{g}_{2}N)$)

在 DFS 遍历期间，将结果保存在按层数索引的全局数组中。即元素 array[level] 存储同一层的所有节点。然后在 DFS 的每一步更新全局数组。

使用双端队列保存同一层的所有节点，并交替插入方向（从首部插入或从尾部插入）得到需要的输出顺序。

1. 如果是第一次访问该层的节点，即该层的双端队列不存在。那么创建一个双端队列，并添加该节点到队列中。
2. 如果当前层的双端队列已存在，根据顺序，将当前节点插入队列头部或尾部。
3. 最后，为每个节点调用该递归方法。

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
from collections import deque

class Solution:
    def zigzagLevelOrder(self, root):
        """
        :type root: TreeNode
        :rtype: List[List[int]]
        """
        if root is None:
            return []

        res = []
        def dfs(node, level):
            if level >= len(res):
                res.append(deque([node.val]))
            else:
                if level % 2 == 0:
                    res[level].append(node.val)
                else:
                    res[level].appendleft(node.val)

            for next_node in [node.left, node.right]:
                if next_node is not None:
                    dfs(next_node, level+1)

        # normal level order traversal with DFS
        dfs(root, 0)

        return [list(item) for item in res]    # 最后需要返回 list，而不是队列

复杂度分析

1. 时间复杂度：$O(N)$，其中N 是树中节点的数量。
2. 空间复杂度：$O(H)$ 或者 $O(lo{g}_{2}N)$，其中 $H$ 是树的高度。例如：包含 $N$ 个节点的树，高度大约为 $lo{g}_{2}N$。

2.2 层次遍历思路，栈实现逆序 (空间复杂度：$O(N)$)

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
from collections import deque

class Solution:
    def zigzagLevelOrder(self, root):
        if not root:
            return []
        res = []
        stack = [root]
        level = 0
        while len(stack) > 0:
            tmp = []
            new_stack = []
            while len(stack) > 0:
                cur = stack.pop()
                tmp.append(cur.val)
                if level % 2 == 0:
                    if cur.left:
                        new_stack.append(cur.left)
                    if cur.right:
                        new_stack.append(cur.right)
                else:
                    if cur.right:
                        new_stack.append(cur.right)
                    if cur.left:
                        new_stack.append(cur.left)
            res.append(tmp)
            stack = new_stack
            level += 1
        return res

复杂度分析

1. 时间复杂度为 $O(N)$
2. 空间复杂度为 $O(1)$

参考：

1. LeetCode题解