分层遍历二叉树 （python）

解法 1

按题目意思一层一层的遍历二叉树。

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def levelOrder(self, root: TreeNode) -> List[List[int]]:
        if not root:
            return []
        res = [[root.val]]
        nextp = [root]
        while nextp:
            ans, p =[], []
            while nextp:
                temp = nextp.pop(0)
                if temp.left:
                    p.append(temp.left) 
                    ans.append(temp.left.val)
                if temp.right:
                    p.append(temp.right) 
                    ans.append(temp.right.val)
            if ans:
                res.append(ans[:])
            nextp = p[:]
        return res
            

解法 2

按索引位置遍历每层的二叉树。

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def levelOrder(self, root: TreeNode) -> List[List[int]]:
        if not root:
            return []
        cur, last = 0, 1
        vec, ans= [], []
        vec.append(root)
        while cur < len(vec):
            last = len(vec)
            res = []
            while cur < last:
                res.append(vec[cur].val)
                if vec[cur].left:
                    vec.append(vec[cur].left)
                if vec[cur].right:
                    vec.append(vec[cur].right)
                cur += 1
            ans.append(res[:])
        return ans
            

解法 3

递归遍历二叉树：

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def levelOrder(self, root: TreeNode) -> List[List[int]]:
        def getlevel(root, level, res):
            if not root or level < 0:
                return 0
            if level == 0:
                res.append(root.val)
                return 1
            return getlevel(root.left, level-1,res) + getlevel(root.right, level-1, res)
        ans,i = [], 0
        while True:
            res = []
            if not getlevel(root, i, res): 
                break
            ans.append(res)
            i += 1
        return ans

class Solution(object):
	def levelOrder(self, root):
		"""
		:type root: TreeNode
		:rtype: List[List[int]]
		"""
		if not root:
			return []
		res = []
		def dfs(index,root):
			if len(res)<index:
				res.append([])
			res[index-1].append(root.val)
			if r.left:
				dfs(index+1,root.left)
			if r.right:
				dfs(index+1,root.right)
		dfs(1,root)
		return res

扩展（从下到上输出每一层的节点值）

1. 递归法

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def levelOrderBottom(self, root: TreeNode) -> List[List[int]]:
        def maxDepth(root):
            if not root:
                return 0
            return max(maxDepth(root.left), maxDepth(root.right)) + 1
        def getNodelevel(root, level, res):
            if not root or level<0:
                return
            if level == 0:
                res.append(root.val)
            getNodelevel(root.left, level-1, res)
            getNodelevel(root.right, level-1, res)
        depth = maxDepth(root)
        ans, res = [], []
        for i in range(depth-1,-1,-1):
            getNodelevel(root, i, res)
            ans.append(res[:])
            res.clear()
        return ans

2.广度优先搜索

class Solution:
    def levelOrderBottom(self, root: TreeNode) -> List[List[int]]:
        levelOrder = list()
        if not root:
            return levelOrder
        
        q = collections.deque([root])
        while q:
            level = list()
            size = len(q)
            for _ in range(size):
                node = q.popleft()
                level.append(node.val)
                if node.left:
                    q.append(node.left)
                if node.right:
                    q.append(node.right)
            levelOrder.append(level)

        return levelOrder[::-1]