技術標籤：leetcode

思路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