leedcode 二叉树的层次遍历

利用队列保存每层的节点，利用一个辅助列表来保存当前层的所有孩子节点。当当前层遍历结束之后，该层的所有孩子节点也会被全部保存再辅助列表中，然后将这个辅助列表赋值给队列。依次循环直到遍历完整棵树。

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

class Solution(object):
    def levelOrder(self, root):
        """
        :type root: TreeNode
        :rtype: List[List[int]]
        """
        queue = []
        queue.append(root)
        res = []
        if root is None:
            return root
        while len(queue) > 0:
            len_q = len(queue)
            temp = []
            node_level = []
            for i in range(len_q):
                node = queue[i]
                temp.append(node.val)
                if node.left:
                    node_level.append(node.left)
                if node.right:
                    node_level.append(node.right)
            queue = node_level
            res.append(temp)
        return res 

二叉树的前序遍历

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

class Solution(object):
    def preorderTraversal(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        res = []
        pnodes = []
        pnodes.append(root)
        while len(pnodes) > 0:
            root = pnodes.pop()
            if not root:
                continue
            res.append(root.val)
            pnodes.append(root.right)
            pnodes.append(root.left)
        return res

二叉树的中序遍历

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

class Solution(object):
    def inorderTraversal(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        res = []
        pnodes = []
        while root or len(pnodes) > 0:
            while root:
                pnodes.append(root)
                root = root.left
            root = pnodes.pop()
            res.append(root.val)
            root = root.right
        return res

二叉树的后序遍历

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

class Solution(object):
    def postorderTraversal(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        res = []
        stack = []
        stack.append((root, False))
        while len(stack) > 0:
            root, visited = stack.pop()
            if not root:
                continue
            if visited:
                res.append(root.val)
            else:
                stack.append((root, True))
                stack.append((root.right, False))
                stack.append((root.left, False))
        return res