leetcode144、94、145：二叉树的前序中序后序遍历

题目描述：
给你二叉树的根节点 root ，返回它节点值的 前、中、后序遍历。
思路：
每一中遍历都有递归方式和非递归两种方式。

1. 先序遍历：
   1） 递归：注意这里的result是为了存放结果，所以要在增加一个函数是必要的。

一个关于二叉树的遍历可以学习的链接

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    def preorderTraversal(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        result = []
        self.preorder(root, result)
        return result

    def preorder(self, root, result):
        if not root:
            return
        result.append(root.val)
        self.preorder(root.left, result)
        self.preorder(root.right, result)

2）利用栈：

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    def preorderTraversal(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        result = []
        # 不用迭代的方式，用栈的思想：先序遍历是先遍历根，然后左子树、右子树
        stack = []
        if not root:
            return result
        stack.append(root)
        while stack:
            root = stack.pop()
            result.append(root.val)
            if root.right:
                stack.append(root.right)
            if root.left:
                stack.append(root.left)
        return result

2. 中序遍历：
   1） 递归：

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    def inorderTraversal(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        result = []
        self.inorder(root, result)
        return result

    def inorder(self, root, result):
        if not root:
            return
        self.inorder(root.left, result)
        result.append(root.val)
        self.inorder(root.right, result)

2）利用栈： 注意写法和先序后序不一样的地方

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    def inorderTraversal(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        result = []
        stack = []   # 利用栈完成非递归的方式，中序遍历先输出最左，然后再输出中间和右
        while stack or root:
            while root:
                stack.append(root)
                root = root.left
            if stack:
                root = stack.pop()
                result.append(root.val)
                root = root.right   # 这里root要是没有right下一轮循环将会被重新赋值
        return result

3. 后序遍历：
   1）递归：

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    def postorderTraversal(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        result = []
        self.postorder(root, result)
        return result

    def postorder(self, root, result):
        if not root:
            return
        self.postorder(root.left, result)
        self.postorder(root.right, result)
        result.append(root.val)

2）利用栈：注意这个思想

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    def postorderTraversal(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        result = []
        stack = []
        if not root:
            return result
        stack.append(root)
        while stack:  # 利用栈，想法：后序遍历是先左再右再根，所以可以采用一种逆序的思想
            # 输出根 右 左  这样在把这个顺序调换过来就可以
            root = stack.pop()
            result.append(root.val)
            if root.left:
                stack.append(root.left)
            if root.right:
                stack.append(root.right)
        return result[::-1]

1、时间复杂度：递归与迭代差不多(在不考虑函数调用开销和函数调用产生的堆栈开销)。
2、空间复杂度：递归开销大一些，因为递归需要系统堆栈存参数返回值等。
总之，递归更容易理解，但收敛不好，容易栈溢出。在实际项目开发，应该避免递归，因为项目代码参数，调用关系比较复杂不容易控制递归深度，甚至会栈溢出。

针对递归算法的一些思考：
1）递归算法会使用更多的内存。因为递归算法会隐式调用递归栈（Recursion Stack），在每次递归调用的时候都会往递归栈里存一些值，直到递归完成才释放。
2）递归如果实现不当的话，会很慢，比如在解决动态规划问题的时候，例如斐波那切数列问题，如果使用递归，会不断重复计算子问题，时间复杂度和孔家复杂度都会很大。

递归有可能引起调用栈溢出，因为递归是函数调用自身，函数调用是有时间和空间消耗的，而调用栈的容量是有限的。另外递归有可能对子问题有重叠计算，造成时间复杂度的增加，但是二叉树的遍历应该不存在。