103. Binary Tree Zigzag Level Order Traversal

最新推荐文章于 2024-08-23 15:23:16 发布

NickChen_0411

最新推荐文章于 2024-08-23 15:23:16 发布

阅读量234

点赞数

CC 4.0 BY-SA版权

分类专栏：算法面试题 LeetCode Python

本文链接：https://blog.youkuaiyun.com/NichChen/article/details/89361517

LeetCode 同时被 3 个专栏收录

67 篇文章

订阅专栏

算法面试题

50 篇文章

订阅专栏

Python

17 篇文章

订阅专栏

本文介绍了一种二叉树的特殊遍历方式——锯齿形层序遍历，通过两种方法实现：一是利用队列进行层次遍历，并根据层数决定输出顺序；二是采用深度优先遍历，根据层的奇偶性决定节点值的插入位置。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Given a binary tree, return the zigzag level order traversal of its nodes' values. (ie, from left to right, then right to left for the next level and alternate between).

For example:
Given binary tree [3,9,20,null,null,15,7],

return its zigzag level order traversal as:

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

Accepted

208.3K

Submissions

505.9K

思路一：

用队列实现树的层次遍历（或广度优先遍历），并用idx记录是否为偶数层，若是则反向输出列表。

代码一：

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

class Solution:
    def zigzagLevelOrder(self, root: TreeNode) -> List[List[int]]:
        queue = []
        tmp = []
        ans = []
        idx = 1
        if root == None:
            return ans
        queue.append(root)
        while len(queue):
            for i in range(len(queue)):
                node = queue[0]
                if node.left != None:
                    queue.append(node.left)
                if node.right != None:
                    queue.append(node.right)
                tmp.append(node.val)
                queue.pop(0)
            if idx%2 == 0:
                tmp = tmp[::-1]
            ans.append(tmp)
            tmp = []
            idx += 1
        return ans

写得比较麻烦，基本是按照C++的代码翻译过来的，下面是比较简洁的python代码：

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

class Solution:
    def zigzagLevelOrder(self, root: TreeNode) -> List[List[int]]:
        res = []
        if not root:
            return res
        tmp = [root]
        idx = 'L'
        while tmp:
            curtmp = []
            nextmp = []
            for node in tmp:
                curtmp.append(node.val)
                if node.left:
                    nextmp.append(node.left)
                if node.right:
                    nextmp.append(node.right)
            if idx == 'L':
                res.append(curtmp)
                idx = 'R'
            else:
                res.append(curtmp[::-1])  # reverse list
                idx = 'L'
            tmp = nextmp  # update queue
        return res

思路二：

深度优先遍历（DFS）

对树进行先序遍历（中序遍历、后序遍历也都可以），逐一放入list中，在奇数层时选择从头插入（insert(0, val)），在偶数层时选择从尾插入(.append())，且需要在list赋值前为res开辟索引空间。

代码二：

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

class Solution:
    def dfs(self, root, level, res):
        if root:
            if len(res) < level+1:
                res.append([])
            
            if level % 2 == 0:
                res[level].append(root.val)
            else:
                res[level].insert(0, root.val)
                
            self.dfs(root.left, level+1, res)
            self.dfs(root.right, level+1, res)    
        
    def zigzagLevelOrder(self, root: TreeNode) -> List[List[int]]:
        res = []
        self.dfs(root, 0, res)
        return res