算法训练营第十四天| LeetCode144. 二叉树的前序遍历、LeetCode145. 二叉树的后序遍历、LeetCode94. 二叉树的中序遍历

二叉树的定义

class TreeNode: 
    def __init__(self, value):
        self.value = value
        self.left = None
        self.right = None

144. 二叉树的前序遍历

给你二叉树的根节点 root ，返回它节点值的 前序 遍历。

输入：root = [1,null,2,3]
输出：[1,2,3]

 解法一：递归法

# 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):
        # # 前序遍历：中左右
        # 使用递归遍历，需要确定的三个条件
        # 1：确定递归函数的参数和返回值
        # 2：确定终止条件
        # 3：确定单层递归的逻辑
        def traversal(cur, res):
            if cur == None:               # 当节点为空，返回到上个节点
                return
            res.append(cur.val)           # 将父节点添加到res
            traversal(cur.left, res)      # 遍历左节点
            traversal(cur.right, res)     # 遍历右节点
        res = []
        cur = root
        traversal(cur, 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 preorderTraversal(self, root):
        # # 前序遍历：中左右
        # 迭代法
        # 使用栈来实现
        stack = []                  # 定义一个栈
        res = []                    # 存遍历节点的数组
        if not root:
            return res
        stack.append(root)          # 将根节点添加到栈中
        while stack:
            node = stack.pop()      # 将栈中最后一个节点弹出
            res.append(node.val)    # 并把节点的值加入到res中
            # 然后将节点的左右子节点添加到栈中
            # 因为前序遍历的顺序是：中左右，栈是先进后出，所以需要先将右节点先入栈，在将左节点入栈
            if node.right:
                stack.append(node.right)       # 当右节点不为空时，先将右节点入栈
            if node.left:
                stack.append(node.left)        # 当左节点不为空时，再将左节点入栈
        return res

94. 二叉树的中序遍历

输入：root = [1,null,2,3]
输出：[1,3,2]

  解法一：递归法

# 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):
        # 中序遍历：左中右
        def traversal(cur, res):
            if cur == None:
                return 
            traversal(cur.left, res)          # 遍历左节点
            res.append(cur.val)               # 左节点遍历完成后，将根节点加入res中
            traversal(cur.right, res)         # 遍历右节点
 
        res = []
        traversal(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 inorderTraversal(self, root):
        # 中序遍历：左中右
        # 迭代法
        # 使用栈和指针来实现，栈用来存放遍历过的元素，指针进行遍历二叉树
        stack = []
        res = []
        cur = root
        if not root:                # 当根节点为空，直接返回[]
            return res
        while cur or stack:
            # 先迭代访问最底层的左子树节点
            if cur != None:            # 当前节点不为空
                stack.append(cur)      # 将当前节点入栈
                cur = cur.left         # 再指向当前节点的左节点
            # 到达最底层左子节点后，处理栈顶元素
            else:                      # 当前节点为空了
                cur = stack.pop()      # 从栈中弹出节点
                res.append(cur.val)    # 将节点的值加入到res中
                cur = cur.right        # 在将cur指向当前节点的右节点
        return res

145. 二叉树的后序遍历

输入：root = [1,null,2,3]
输出：[3,2,1]

 解法一：递归法

# 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):
        # 后序遍历：左右中
        # 使用递归遍历，需要确认三个条件
        # 1：确定递归函数的参数和返回值
        # 2：确定终止条件
        # 3：确定单层递归的逻辑
        def traversal(cur, res):
            if cur == None:
                return
            traversal(cur.left, res)
            traversal(cur.right, res)
            res.append(cur.val)           
        
        res = []
        traversal(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):
        # 后序遍历：左右中
        # 迭代法
        # 使用栈来实现
        stack = []
        res = []
        if not root:
            return res
        # 因为后序遍历的顺序是：左右中，可以将顺序改为中右左，最后再将得到的res进行一个翻转即可
        stack.append(root)                    # 将根节点root加入栈stack中
        while stack:
            node = stack.pop()                # 将根节点从栈中弹出
            res.append(node.val)              # 将根节点的值，添加到数组res中
            # 我们添加到res的顺序是中右左，栈是先进后出，所以先将左节点入栈，再将右节点入栈
            if node.left:
                stack.append(node.left)       # 左节点不为空，则入栈
            if node.right:
                stack.append(node.right)      # 右节点不为空，则入栈
        # 此时res中的结果是按照中右左的顺序进行遍历得到的结果，需要将res中的元素进行翻转
        res.reverse()                         # 翻转数组
        return res

 “初心如磐，奋楫笃行”