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

最新推荐文章于 2024-08-12 11:55:09 发布

HY.YUE

最新推荐文章于 2024-08-12 11:55:09 发布

阅读量180

点赞数 1

分类专栏： LeetCode 文章标签： python leetcode

本文链接：https://blog.csdn.net/weixin_42286468/article/details/130828417

版权

LeetCode 专栏收录该内容

53 篇文章 5 订阅

订阅专栏

本文介绍了二叉树的基础知识，包括二叉树的类型、存储方式和遍历方法。详细讲解了前序、中序和后序遍历的递归和迭代实现，并给出了相关编程题目的示例。此外，还提到了C++中map和set等数据结构的底层实现与二叉搜索树的关系。

摘要由CSDN通过智能技术生成

今日任务

理论基础

讲解：代码随想录

二叉树是一种基础数据结构，在算法面试中都是常客，也是众多数据结构的基石。

二叉树的种类：

满二叉树：如果一棵二叉树只有度为0的结点和度为2的结点，并且度为0的结点在同一层上，则这棵二叉树为满二叉树。也可以说深度为k，有2^k-1个节点的二叉树。
完全二叉树：在完全二叉树中，除了最底层节点可能没填满外，其余每层节点数都达到最大值，并且最下面一层的节点都集中在该层最左边的若干位置。若最底层为第 h 层，则该层包含 1~ 2^(h-1) 个节点。优先级队列其实是一个堆，堆就是一棵完全二叉树，同时保证父子节点的顺序关系。
二叉搜索树：二叉搜索树是一个有序树。
若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值
若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值
它的左、右子树也分别为二叉排序树
平衡二叉搜索树：又被称为AVL（Adelson-Velsky and Landis）树，它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。

C++中map、set、multimap，multiset的底层实现都是平衡二叉搜索树，所以map、set的增删操作时间时间复杂度是logn，注意我这里没有说unordered_map、unordered_set，unordered_map、unordered_set底层实现是哈希表。

二叉树的存储方式：

链式存储：通过指针把分布在各个地址的节点串联一起，一般都是用链式存储二叉树。

顺序存储：使用数组，将存储的元素在内存连续分布；如果父节点的数组下标是 i，那么它的左孩子就是 i * 2 + 1，右孩子就是 i * 2 + 2。

二叉树的遍历方式：

深度优先遍历：下面的前中后，指的是中间节点的遍历顺序。常用递归的方式实现，也可以借助栈使用非递归的方式来实现的
前序遍历（递归法，迭代法）
中序遍历（递归法，迭代法）
后序遍历（递归法，迭代法）
广度优先遍历：一般使用队列来实现，因为需要先进先出的结构，才能一层一层的来遍历二叉树
层次遍历（迭代法）

二叉树的定义：

二叉树的定义和链表是差不多的，相对于链表，二叉树的节点里多了一个指针，有两个指针，指向左右孩子。
class TreeNode:
    def __init__(self, value):
        self.value = value
        self.left = None
        self.right = None

144.二叉树的前序遍历 - Easy

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

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

递归遍历

# 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]
        res = []
        while stack:
            node = stack.pop()
            res.append(node.val)
            if node.right:
                stack.append(node.right)
            if node.left:
                stack.append(node.left)
        return res

94.二叉树的中序遍历 - Easy

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

给定一个二叉树的根节点 root ，返回 它的中序遍历 。

递归遍历

# 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 = []
        res = []
        cur = root
        while cur or stack:
            if cur:
                stack.append(cur)
                cur = cur.left
            else:
                cur = stack.pop()
                res.append(cur.val)
                cur = cur.right
        return res

145.二叉树的后序遍历 - Easy

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

给你一棵二叉树的根节点 root ，返回其节点值的后序遍历。

递归遍历

# 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]
        res = []
        while stack:
            node = stack.pop()
            res.append(node.val)
            if node.left:
                stack.append(node.left)
            if node.right:
                stack.append(node.right)
        return res[::-1]