【Leetcode】429. N-ary Tree Level Order Traversal 解题报告

层次遍历N岔树

class Solution1(object):
    # 递归法，将节点所在的层数作为参数，层数与数组的位置一一对应
    def levelOrder(self, root):
        """
        :type root: Node
        :rtype: List[List[int]]
        """
        self.res = []
        self.DFS(root, 1)
        return self.res


    def DFS(self, root, level):
        if len(self.res) < level:
            self.res.append([])
        level +=1
        self.res[level].append(root.val)
        for child in root.children:
            self.DFS(child, level+1)


class Solution2(object):
    def levelOrder(self, root):
        """
        :type root: Node
        :rtype: List[List[int]]
        """
        # 深搜非递归的形式，将节点与level 一起保存
        # 要注意的是，因为用的是栈，所以遍历孩子的时候需要倒序入栈
        if root == None:
            return []
        stack = [[root, 1]]
        res = []
        while(len(stack)):
            node,level = stack.pop()
            if len(res) < level:
                res.append([])
            res[level-1].append(node.val)
            tmp = []
            for child in node.children:
                tmp.append([child, level+1])
            stack.extend(tmp[::-1])
        return res

class Solution3(object):
    def levelOrder(self, root):
        """
        :type root: Node
        :rtype: List[List[int]]
        """
        # 广搜的非递归形式，但仍然保存了节点的层数，用队列就不用像方法2中那样对child节点倒序入栈
        if root == None:
            return []
        from collections import  deque
        queue = deque()
        queue.append([root, 1])
        res = []
        while(len(queue)):
            node,level = queue.pop()
            if len(res) < level:
                res.append([])
            res[level-1].append(node.val)
            if node.left:
                queue.append([node.left, level+1])
            if node.right:
                queue.append([node.right, level+1])
        return res

class Solution4(object):
    def levelOrder(self, root):
        """
        :type root: Node
        :rtype: List[List[int]]
        """
        # 广搜非递归的形式，用一个变量记录层数即可
        if root == None:
            return []
        from collections import  deque
        queue = deque()
        queue.append(root)
        depth = 0
        res = []
        while(len(queue)):
            depth +=1
            res.append([])
            length = len(queue)
            for i in range(length):
                node = queue.popleft()
                res[-1].append(node.val)
                for child in node.children:
                    queue.append(child)
        return res