leetcode探索-二叉树-树的遍历(1)

'''
Created on Mon Jun 22  2020
@author: Ljh
Language: python
'''

1.二叉树的前序遍历
题目：给定一个二叉树，返回它的前序遍历
方法一：递归

#递归方式：根左右
class Solution:
    def __init__(self):
        self.res = []
    def preorderTraversal(self, root: TreeNode) -> List[int]:        
        if not root:
            return  []
        self.res.append(root.val)
        self.preorderTraversal(root.left)
        self.preorderTraversal(root.right)
        return self.res

方法二：迭代

# 使用辅助栈-先入后出
class Solution:
    def preorderTraversal(self, root: TreeNode) -> List[int]:
        if not root: return []
        stack,res= [root],[]
        while stack:
            node = stack.pop()
            if node.right:
                stack.append(node.right)
            if node.left:
                stack.append(node.left)
            res.append(node.val)
        return res

2.二叉树的中序遍历
题目：给定一个二叉树，返回它的中序遍历
方法一：递归

#递归方式：左根右
class Solution:
    def __init__(self):
        self.res = []
    def inorderTraversal(self, root: TreeNode) -> List[int]:
        if not root: return []
        self.inorderTraversal(root.left)
        self.res.append(root.val)
        self.inorderTraversal(root.right)
        return self.res

方法二：迭代

# 辅助栈-循环左孩子入栈
class Solution:
    def inorderTraversal(self, root: TreeNode) -> List[int]:
        if not root: return []
        stack,res = [],[]
        while root or len(stack) >0:
            if root:
                stack.append(root)
                root = root.left
            else:
                node = stack.pop()
                res.append(node.val)
                if node.right != None:
                    root = node.right
        return res

3.二叉树的后序遍历
题目：给定一个二叉树，返回它的后序遍历
方法一：递归

#递归方式：左右根
class Solution:
    def __init__(self):
        self.res = []
    def postorderTraversal(self, root: TreeNode) -> List[int]:
        if not root:
            return []
        self.postorderTraversal(root.left)
        self.postorderTraversal(root.right)
        self.res.append(root.val)
        return self.res

方法二：迭代

#相对于前序和中序 复杂较多
class Solution:
    def postorderTraversal(self, root: TreeNode) -> List[int]:
        if not root: return []
        stack,res = [], []
        node = root
        while node or len(stack) >0:
            while node:
                stack.append(node)
                if node.left:
                    node = node.left
                else:
                    node = node.right
            node = stack.pop()
            res.append(node.val)
            if stack and stack[-1].left == node:
                node = stack[-1].right
            else:
                node = None
        return res

方法三：巧技

#取巧算法 -前序遍历修改左右孩子入栈顺序，即根右左的顺序，最后将结果倒序
class Solution:
    def postorderTraversal(self, root: TreeNode) -> List[int]:
        if not root: return []
        stack,res = [root], []
        while stack:
            node = stack.pop()
            if node.left:
                stack.append(node.left)
            if node.right:
                stack.append(node.right)
            res.append(node.val)
        return res[::-1]	

4.二叉树的层序遍历 - 广度优先搜索
题目：给你一个二叉树，请你返回其按 层序遍历 得到的节点值。 （即逐层地，从左到右访问所有节点）

#使用队列的想法
class Solution:
    def levelOrder(self, root: TreeNode) -> List[List[int]]:
        if not root: return []
        Q,res = collections.deque(),[]
        Q.append(root)
        while Q:
            tmp = []
            for _ in range(len(Q)):
                node = Q.popleft()
                tmp.append(node.val)
                if node.left:
                    Q.append(node.left)
                if node.right:
                    Q.append(node.right)
            res.append(tmp)
        return res