代码随想录算法训练营第14天 | 144.二叉树的前序遍历 + 94.二叉树的中序遍历 + 145.二叉树的后序遍历-CSDN博客

本文链接：https://blog.csdn.net/weixin_63840907/article/details/132676516

今日任务：

二叉树理论基础
144.二叉树的前序遍历
94.二叉树的中序遍历
145.二叉树的后序遍历

二叉树理论基础：

二叉树的种类：

满二叉树：

定义：如果一棵二叉树只有度为0的结点和度为2的结点，并且度为0的结点在同一层上，则这棵二叉树为满二叉树

完全二叉树：

定义：在完全二叉树中，除了最底层节点可能没填满外，其余每层节点数都达到最大值，并且最下面一层的节点都集中在该层最左边的若干位置。若最底层为第h层（h从1开始），则该层包含1~ $2^{h-1}$ 个节点。
优先级队列其实就是一个堆，堆就是一颗完全二叉树，同时保证父子节点的顺序关系。

二叉搜索树：

若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值
若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值
它的左、右子树也分别为二叉排序树

平衡二叉搜索树：

平衡二叉搜索树：又被称为AVL（Adelson-Velsky and Landis）树，且具有以下性质：它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。

二叉树的存储方式：

二叉树可以链式存储（用指针），也可以顺序存储（用数组）

二叉树遍历方式：

二叉树中深度优先和广度优先遍历实现方式，我们做二叉树相关题目，经常会使用递归的方式来实现深度优先遍历，也就是实现前中后序遍历，使用递归是比较方便的。

递归是一种实现结构，也就说前中后序遍历的逻辑其实都是可以借助栈使用递归的方式来实现的。

而广度优先遍历的实现一般使用队列来实现，这也是队列先进先出的特点所决定的，因为需要先进先出的结构，才能一层一层的来遍历二叉树。

二叉树的定义：

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

144.二叉树的前序遍历

题目链接：144. 二叉树的前序遍历 - 力扣（LeetCode）

递归遍历：

# 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: Optional[TreeNode]) -> List[int]:
        if not root:
            return []

        left = self.preorderTraversal(root.left)
        right = self.preorderTraversal(root.right)

        return [root.val] + left + right

迭代遍历：

# 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: Optional[TreeNode]) -> List[int]:
        if not root:
            return []

        stack = [root]

        result = []

        while stack:
            node = stack.pop()
            #中结点先处理
            result.append(node.val)
            #右孩子先入栈
            if node.right:
                stack.append(node.right)
            
            #左孩子后入栈
            if node.left:
                stack.append(node.left)

        return result

94.二叉树的中序遍历

题目链接：94. 二叉树的中序遍历 - 力扣（LeetCode）

递归遍历：

# 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: Optional[TreeNode]) -> List[int]:
        if not root:
            return []

        left = self.inorderTraversal(root.left)
        right = self.inorderTraversal(root.right)

        return left+[root.val]+right

迭代遍历：

# 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: Optional[TreeNode]) -> List[int]:
        if not root:
            return []

        stack = []#不能提前将root结点加入stack中
        result = []
        cur = root

        while cur or stack:
            #先迭代访问最底层的左子树结点
            if cur:
                stack.append(cur)
                cur = cur.left
            # 到达最左结点后处理栈顶结点
            else:
                cur = stack.pop()
                result.append(cur.val)
                cur = cur.right

        return result

145.二叉树的后序遍历

题目链接：145. 二叉树的后序遍历 - 力扣（LeetCode）

递归遍历：

# 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: Optional[TreeNode]) -> List[int]:
        if not root:
            return []

        left = self.postorderTraversal(root.left)
        right = self.postorderTraversal(root.right)

        return left + right + [root.val]

迭代遍历：

# 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: Optional[TreeNode]) -> List[int]:
        if not root:
            return []

        stack = [root]

        result = []
        while stack:
            node = stack.pop()

            result.append(node.val)

            if node.left:
                stack.append(node.left)

            if node.right:
                stack.append(node.right)

        return result[::-1]