算法随笔-二叉树遍历的N种姿势

最近在练习用Python刷算法，leetcode上刷了快300题。一开始怀疑自己根本不会写代码，现在觉得会写一点点了，痛苦又充实的刷题历程。对我这种半路出家的人而言，收获真的很大。

今天就从二叉树遍历写起，曾经有次面试就被迭代实现卡过。。。

最简单的递归

#先序遍历
def preorderTraversal(self, root: TreeNode) -> List[int]:
        res=[]
        def preTraversal(node,result):
            if node==None:
                return
            #输出放在最前
            result.append(node.val)
            preTraversal(node.left,result)
            preTraversal(node.right,result)
        preTraversal(root,res)
        return res
 
#中序遍历
def inorderTraversal(self, root: TreeNode) -> List[int]:
        res=[]
        def inorderTraversal(node,result):
            if node==None:
                return
            inorderTraversal(node.left,result)
            #输出放在中间
            result.append(node.val)
            inorderTraversal(node.right,result)
        inorderTraversal(root,res)
        return res
 
#后序遍历
def postorderTraversal(self, root: TreeNode) -> List[int]:
        res=[]
        def postTraversal(node,result):
            if node==None:
                return
            postTraversal(node.left,result)
            postTraversal(node.right,result)
            #输出放在最后
            result.append(node.val)
        postTraversal(root,res)
        return res

　　递归实现极其简单，但是面试时往往会更进一步，问几个深入一点的问题：

递归实现存在什么问题？
尾递归是什么？

这两个问题都在讲一件事，就是迭代实现的二叉树遍历会存在StackOverflow异常。却决于操作系统和运行时，不同的程序拥有的栈大小不一，但是栈的容量都是较小的，基于递归的实现，如果未优化，就会导致堆栈溢出的异常。对.NET而言，系统分配的默认栈空间大小是1MB，树节点一多，很容就满了。

而尾递归则是对普通递归的优化，每次迭代最后都是直接调用自身。很多编译器都对尾递归做了生成优化，使得它可以不在调用栈上面每次都添加一个新的堆栈帧，而是更新它。这样就不会导致调用栈爆炸的异常。

如果你能答上上面的问题，往往会让你写一下二叉树遍历非递归的实现，这里难度就上了一个台阶。

非递归实现

二叉树迭代一定会用到栈！二叉树迭代一定会用到栈！二叉树迭代一定会用到栈！

talk is easy, show you my code

#超简单的先序遍历
def preorderTraversal(self, root: TreeNode) -> List[int]:
        res=[]
        if root==None:
            return
        stack=[root]
        while stack:
            node=stack.pop()
            res.append(node.val)
            #栈先进后出，顺序要注意
            if node.right:
                stack.append(node.right)
            if node.left:
                stack.append(node.left)
        return res
 
#稍复杂的中序遍历
def inorderTraversal(self, root: TreeNode) -> List[int]:
        res=[]
        curr=root
        stack=[]
        while curr or stack:
            #优先遍历全部左节点
            while curr:
                stack.append(curr)
                curr=curr.left
            node=stack.pop()
            res.append(node.val)
            #当前节点切换到右节点
            if node.right:
                curr=node.right
        return res
 
#最复杂的后序遍历
#解法1 基于先序遍历的变形  leetcode官方题解：https://leetcode-cn.com/problems/binary-tree-postorder-traversal/solution/er-cha-shu-de-hou-xu-bian-li-by-leetcode/
 
def postorderTraversal(self, root: TreeNode) -> List[int]:
        res=[]
        if root==None:
            return res
        stack=[root]
        while stack:
            node=stack.pop()
            res.append(node.val)
            if node.left:
                stack.append(node.left)
            if node.right:
                stack.append(node.right)
        #反转结果
        return res[::-1]
 
#解法2 记录走过的路径
def postorderTraversal(self, root: TreeNode) -> List[int]:
        res=[]
        if root==None:
            return res
        stack=[root]
        km=set()
        while stack:
            node=stack[-1]
            #只有叶子节点和左右节点被遍历过的才可以输出
            if (node.left==None and node.right==None) or (node.left in km or node.right in km):
                res.append(node.val)
                km.add(node)
                stack.pop()
            else:
                #注意进栈顺序
                if node.right:
                    stack.append(node.right)
                if node.left:
                    stack.append(node.left)
        return res
 
#解法3 中序遍历的变形,左右子树遍历切换
def postorderTraversal(self, root: TreeNode) -> List[int]:
        res=[]
        if root==None:
            return res
        stack=[]
        curr=root
        last=None
        while curr or stack:
            if curr:
                stack.append(curr)
                #切换到左子树
                curr=curr.left
            else:
                node=stack[-1]
                #是否切换到右子树
                if node.right and node.right!=last:
                    curr=node.right
                else:
                    res.append(node.val)
                    stack.pop()
                    last=node
        return res