Day13代码随想录二叉树递归遍历 & 迭代遍历 & 统一的迭代遍历 & 层次遍历

最新推荐文章于 2025-12-18 21:45:56 发布

原创最新推荐文章于 2025-12-18 21:45:56 发布 · 945 阅读

16 ·

CC 4.0 BY-SA版权

文章标签：

#数据结构

二叉树的基础知识

二叉树的种类(重点介绍两类)

完全二叉树
满二叉树

满二叉树

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

如下图所示：

完全二叉树

定义：在完全二叉树中，除了最底层节点可能没填满外，其余各层节点数都达到了最大值，并且最下面一层的节点都集中在该层最左边的若干位置。若最底层为第h层（h从1开始）则该层包含1~2^(h-1)个节点。

在这里插入图片描述

之前所说优先级队列其实是一个堆，而堆就是一棵完全二叉树。同时保证父子节点的顺序关系

二叉搜索树

二叉搜索树是一个有序树。

若它的左子树不空，则左子树所有节点的值均小于其根节点的值。
若它的右子树不空，则右子树所有节点的值均大于其根节点的值。
左右子树分别是二叉排序树。

平衡二叉搜索树

在这里插入图片描述

平衡二叉搜索树：又被称为AVL（Adelson-Velsky and Landis）树，且具有以下性质：

它是一棵空树或者它的两个左右子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。

最后一棵树不是平衡二叉树，因为其左右两个子树的高度差的绝对值超过1。

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

所以使用熟悉的编程语言写算法，一定要知道常用的容器底层都是如何实现的，最基本的就是map、set等等，否则自己写的代码，自己对其性能分析都分析不清楚！

二叉树的存储方式

链式存储的方式是利用指针，顺序存储的方式是用数组。

链式存储

通过指针把分布在各个地址的节点串联在一起。

在这里插入图片描述

顺序存储

内存是连续分布的。

在这里插入图片描述

遍历的方法：

如果父节点的数组下标是 $i$ ，那么它的左孩子就是 $2 * i + 1$ ，右孩子就是 $2 * i + 2$

二叉树的遍历方式

深度优先遍历：先往深处走，遇到叶子结点再往回走。
广度优先遍历：一层一层的去遍历。

深度搜索

前序遍历（递归法，迭代法）
中序遍历（递归法，迭代法）
后序遍历（递归法，迭代法）

这里的前中后，指的其实就是中间节点的遍历顺序

广度搜索

层次遍历

利用队列实现。

树的Python实现

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

二叉树的递归遍历

递归思想的三要素

确定递归函数的参数和返回值：确定哪些参数是递归的过程中需要处理的，那么就在递归函数里加上这个参数，并且还要明确每次递归的返回值是什么进而确定递归函数的返回类型。
确定终止条件：写完了递归算法, 运行的时候，经常会遇到栈溢出的错误，就是没写终止条件或者终止条件写的不对，操作系统也是用一个栈的结构来保存每一层递归的信息，如果递归没有终止，操作系统的内存栈必然就会溢出。
确定单层递归的逻辑：确定每一层递归需要处理的信息。在这里也就会重复调用自己来实现递归的过程。

前序 & 中序 & 后序遍历的递归实现

前序遍历

class Solution:
    def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        res = []
        def PT(node):
            if node == None:
                return
            res.append(node.val)
            PT(node.left)
            PT(node.right)
        PT(root)
        return res

中序遍历：

    def inorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        res = []
        def IT(node):
            if node == None:
                return
            IT(node.left)
            res.append(node.val)
            IT(node.right)
        IT(root)
        return res

后序遍历：

    def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        res = []
        def PT(node):
            if node == None:
                return
            PT(node.left)
            PT(node.right)
            res.append(node.val)
        PT(root)
        return res

二叉树的迭代遍历

所有的递归算法可以用改写为迭代算法。

二叉树的迭代遍历

前序遍历

class Solution:
    def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        if root == None:
            return []
        res = []
        stack = [root]
        while stack:
            node = stack.pop()
            res.append(node.val)
            if node.right:
                stack.append(node.right)
            if node.left:
                stack.append(node.left)

后序遍历

class Solution:
    def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        if root == None:
            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 ]

中序遍历

class Solution:
    def inorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        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

二叉树的统一迭代遍历(空指针遍历法)

程序实现

前序遍历

class Solution:
    def preorderTraversal(self, root: TreeNode) -> List[int]:
        result = []
        st= []
        if root:
            st.append(root)
        while st:
            node = st.pop()
            if node != None:
                if node.right: #右
                    st.append(node.right)
                if node.left: #左
                    st.append(node.left)
                st.append(node) #中
                st.append(None)
            else:
                node = st.pop()
                result.append(node.val)
        return result

中序遍历

class Solution:
    def inorderTraversal(self, root: TreeNode) -> List[int]:
        result = []
        st = []
        if root:
            st.append(root)
        while st:
            node = st.pop()
            if node != None:
                if node.right: #添加右节点（空节点不入栈）
                    st.append(node.right)
                
                st.append(node) #添加中节点
                st.append(None) #中节点访问过，但是还没有处理，加入空节点做为标记。
                
                if node.left: #添加左节点（空节点不入栈）
                    st.append(node.left)
            else: #只有遇到空节点的时候，才将下一个节点放进结果集
                node = st.pop() #重新取出栈中元素
                result.append(node.val) #加入到结果集
        return result

后序遍历

lass Solution:
    def postorderTraversal(self, root: TreeNode) -> List[int]:
        result = []
        st = []
        if root:
            st.append(root)
        while st:
            node = st.pop()
            if node != None:
                st.append(node) #中
                st.append(None)
                
                if node.right: #右
                    st.append(node.right)
                if node.left: #左
                    st.append(node.left)
            else:
                node = st.pop()
                result.append(node.val)
        return result

二叉树的层序遍历

程序实现

主要思想是应用双端队列实现层序遍历

class Solution:
    def levelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
        que = deque()
        result = []
        row = 0
        if root == None:
            return []
        else:
            que.append(root)
        while que:
            size = len(que)
            result.append([])
            for i in range(size):
                node = que.popleft()
                result[row].append(node.val)
                if node.left:
                    que.append(node.left)
                if node.right:
                    que.append(node.right)
            row += 1
        return result