leetcode【中等】94、144、145二叉树的中序、前序、后序遍历

思路1：递归

中序遍历：
一直向左遍历，直到最后一层最左边，打印当前，转向右边

inorder(root.left)
	inorder(root.left)
		inorder(root.left)
			为null返回
		打印节点
		inorder(root.right)
			inorder(root.left)
				inorder(root.left)
				........

# 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 inorderTraversal(self, root: TreeNode) -> List[int]:
        
        def inorder(root,res):
            if not root:
                return
            inorder(root.left,res)#左
            res.append(root.val)#打印
            inorder(root.right,res)#有
        
        res=[]
        inorder(root,res)
        return res

注：也可以把res提前声明，indorder函数里不必传递res参数，但不知道为啥效率变低了

class Solution:
    def inorderTraversal(self, root: TreeNode) -> List[int]:
        res=[]
        def inorder(root):
            if not root:
                return
            inorder(root.left)
            res.append(root.val)
            inorder(root.right)
                
        inorder(root)
        return res

前序遍历：

# 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 preorderTraversal(self, root: TreeNode) -> List[int]:
        def preorder(root,res):
            if not root:
                return
            res.append(root.val)
            preorder(root.left,res)
            preorder(root.right,res)

        res=[]
        preorder(root,res)
        return res

后序遍历：

# 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 postorderTraversal(self, root: TreeNode) -> List[int]:
        def postorder(root,res):
            if not root:
                return
            postorder(root.left,res)
            postorder(root.right,res)
            res.append(root.val)

        res=[]
        postorder(root,res)
        return res

思路2：非递归（迭代）
中序遍历：

class Solution:
    def inorderTraversal(self, root: TreeNode) -> List[int]:
        res=[]
        stack=[]

        while root or stack:
            if root:
                stack.append(root)
                root=root.left#找到最左
            else:
                tem=stack.pop()
                res.append(tem.val)#中
                root=tem.right#右
        return res

前序遍历：

class Solution:
    def preorderTraversal(self, root: TreeNode) -> List[int]:
        res=[]
        stack=[]

        while root or stack:
            if root:
                stack.append(root)
                res.append(root.val)#中
                root=root.left#左
            else:
                tem=stack.pop()
                root=tem.right#右
        return res

后序遍历：（本来是左右中，可以中右左然后每次插入到列表开端）

class Solution:
    def postorderTraversal(self, root: TreeNode) -> List[int]:
        res=[]
        stack=[]

        while root or stack:
            if root:
                stack.append(root)
                res.insert(0,root.val)#中，每次插入到最前面
                root=root.right#右
            else:
                tem=stack.pop()
                root=tem.left#左
        return res