leetcode第589、590、429题——N叉树的前序遍历、后序遍历、层序遍历(python)

1.题目描述

给定一个 N 叉树，返回其节点值的前序、后序、层序遍历。

说明:
树的深度不会超过 1000。
树的节点总数不会超过 5000。

例如，给定一个 3叉树 :

2.python代码(迭代+递归)

class Node(object):
    def __init__(self, val, children):
        self.val = val
        self.children = children


class Solution:

    def preorder_iteration(self, root):
        """N叉树前序遍历-迭代"""
        if root is None:
            return []
        res = []
        queue = [root]
        while queue:
            node = queue.pop(0)
            if node:
                res.append(node.val)
                for child in node.children[::-1]:
                    queue.insert(0, child)
        return res

    def preorder_recursion(self, root):
        """N叉树前序遍历-递归"""
        res = []
        if root is None:
            return res
        res.append(root.val)
        for child in root.children:
            res.extend(self.preorder_recursion(child))
        return res

    def postorder_iteration(self, root):
        """N叉树后序遍历-迭代"""
        if root is None:
            return []
        res = []
        queue = [root]
        while queue:
            # 弹出列表尾部的元素
            node = queue.pop()
            res.append(node.val)
            for child in node.children:
                queue.append(child)
        return res[::-1]

    def postorder_recursion(self, root):
        """N叉树后序遍历-递归"""
        if root is None:
            return []
        res = []
        for child in root.children:
            res.extend(self.postorder_recursion(child))
        res.append(root.val)
        return res

    def levelorder1(self, root):
        """N叉树层序遍历-不分层输出"""
        if root is None:
            return []
        res = []
        queue = [root]  # 队列，每次往队尾增加节点
        while queue:
            node = queue.pop(0)  # 每次从队头取出节点，把节点值追加到res
            res.append(node.val)
            for child in node.children:
                # 如果该节点有子节点，则继续往队尾追加该节点的子节点
                queue.append(child)
        return res

    def levelorder2(self, root):
        """N叉树层序遍历-分层输出"""
        if root is None:
            return []
        queue = [(root, 0)]  # 队列元素为元组，方便记录处于第几层。根结点按第0层处理
        res = [[]]
        while queue:
            node, level = queue.pop(0)  # 从队列头部取元素，得到节点及所处层
            if len(res) <= level:
                # 如果len(res)结果所表示的层级数 <= 当前取出来的节点的层级就给res追加一层[]用于保存该层的节点值(=号关键)
                res.append([])
            res[level].append(node.val)  # 根据索引找到对应的层，追加该层的节点值
            for i in node.children:
                queue.append((i, level+1))
        return res



root = Node(1, [Node(3, [Node(5, []), Node(6, [])]), Node(2, []), Node(4, [])])
result1 = Solution().preorder_iteration(root)  # 前序遍历: [1, 3, 5, 6, 2, 4]
# result1 = Solution().preorder_recursion(root)  # 前序遍历: [1, 3, 5, 6, 2, 4]
print(result1)
result2 = Solution().postorder_recursion(root)  # 后序遍历: [5, 6, 3, 2, 4, 1]
# result2 = Solution().postorder_iteration(root)  # 后序遍历: [5, 6, 3, 2, 4, 1]
print(result2)

result3 = Solution().levelorder1(root)  # 层序遍历-不分层打印: [1, 3, 2, 4, 5, 6]
print(result3)
result4 = Solution().levelorder2(root)  # 层序遍历-分层打印: [[1], [3, 2, 4], [5, 6]]
print(result4)