二叉树的遍历

前序遍历

根节点 -> 左子树 -> 右子树
前序遍历直行结果为：[1,2,4,8,9,5,10,11,3,6,12,13,7,14,15]
递归法

# 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 = []
        def bactrack(root):
            if root!=None:
                # 根节点
                res.append(root.val)
                # 遍历左子树
                bactrack(root.left)
                # 右子树
                bactrack(root.right)
        bactrack(root)
        return res

迭代法
从根节点开始，每次迭代弹出当前栈顶元素，并将其孩子节点压入栈中，先压右孩子再压左孩子。
在这个算法中，输出到最终结果的顺序按照 Top->Bottom 和 Left->Right，符合前序遍历的顺序。

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

'''
时间复杂度：访问每个节点恰好一次，时间复杂度为 O(N) ，其中 N 是节点的个数，也就是树的大小。
空间复杂度：取决于树的结构，最坏情况存储整棵树，因此空间复杂度是 O(N)。
'''
class Solution:
    def preorderTraversal(self, root: TreeNode) -> List[int]:
        if root is None:
            return []
        else:
            res = []
            stack = [root]
            while stack != []:
                root = stack.pop()
                # 保存根节点
                res.append(root.val)
                # 先将右子树压入栈中
                if root.right != None:
                    stack.append(root.right)
                # 再将左子树压入栈中
                if root.left != None:
                    stack.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 __init__(self):
        self.ret = []
    def inorderTraversal(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        if root!=None:
            self.inorderTraversal(root.left)
            self.ret.append(root.val)
            self.inorderTraversal(root.right)
        return self.ret 

后序遍历

左子树 -> 右子树 -> 根节点。
和前序遍历的迭代法区分，前序遍历是先压右子树，再压左子树。后序遍历是先压左子树，再压右子树，而且输出的结果是反的。

class Solution(object):
    def postorderTraversal(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        和前序遍历的迭代法区分
        前序遍历是先压右子树，再压左子树。
        后序遍历是先压左子树，再压右子树，而且输出的结果是反的。
        """
        if root is None:
            return []

        stack, output = [root], []
        while stack:
            root = stack.pop()
            output.append(root.val)
            # 先将左子树压入栈中
            if root.left is not None:
                stack.append(root.left)
            # 再将右子树压入栈中
            if root.right is not None:
                stack.append(root.right)
                
        return output[::-1]

递归

# 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 = []
        def postorder(root):
            if root != None:
                postorder(root.left)
                postorder(root.right)
                res.append(root.val)
        postorder(root)
        return res