day13 二叉树理论基础 递归遍历 迭代遍历 层序遍历

最新推荐文章于 2024-10-16 07:16:00 发布
最新推荐文章于 2024-10-16 07:16:00 发布
阅读量904 收藏 13
点赞数 16
文章标签： 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_79240694/article/details/142471528
版权

144.二叉树的前序遍历

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

示例 1：

输入：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: Optional[TreeNode]) -> List[int]:
        res = []

        def dfs(node):
            if node == None:
                return

            res.append(node.val)
            dfs(node.left)
            dfs(node.right)

        dfs(root)
        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: 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

145.二叉树的后序遍历

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

示例 1：

输入：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: Optional[TreeNode]) -> List[int]:
        res = []

        def dfs(node):
            if node == None:
                return

            dfs(node.left)
            dfs(node.right)
            res.append(node.val)

        dfs(root)

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

        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]

 94.二叉树的中序遍历

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

示例 1：

输入：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: Optional[TreeNode]) -> List[int]:
        res = []

        def dfs(node):
            if node == None:
                return

            dfs(node.left)
            res.append(node.val)
            dfs(node.right)

        dfs(root)

        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: Optional[TreeNode]) -> List[int]:
        if not root:
            return []
        res = []
        stack = [] # 不能提前将root节点放入stack中
        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

102. 二叉树的层序遍历

给你二叉树的根节点 root ，返回其节点值的 层序遍历 。 （即逐层地，从左到右访问所有节点）。

示例 1：

输入：root = [3,9,20,null,null,15,7]
输出：[[3],[9,20],[15,7]]

第一种方法 （借助队列法）：

# 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 levelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
        if not root:
            return []
        queue = collections.deque([root])
        result = []
        while queue:
            level = []
            for _ in range(len(queue)):
                cur = queue.popleft()
                level.append(cur.val)
                if cur.left:
                    queue.append(cur.left)
                if cur.right:
                    queue.append(cur.right)
            
            result.append(level)
        
        return result

第二种方法（迭代法）：

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

        levels = []

        def traverse(node, level):
            if not node:
                return []

            if len(levels) == level:
                levels.append([])

            levels[level].append(node.val)
            traverse(node.left, level + 1)
            traverse(node.right, level + 1)
        
        traverse(root, 0)
        return levels

107. 二叉树的层序遍历 II

给你二叉树的根节点 root ，返回其节点值 自底向上的层序遍历 。 （即按从叶子节点所在层到根节点所在的层，逐层从左向右遍历）

示例 1：

输入：root = [3,9,20,null,null,15,7]
输出：[[15,7],[9,20],[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 levelOrderBottom(self, root: Optional[TreeNode]) -> List[List[int]]:
        if not root:
            return []
        result = []
        queue = collections.deque([root])
        
        while queue:
            level = []
            for _ in range(len(queue)):
                node = queue.popleft()
                level.append(node.val)
                if node.left:
                    queue.append(node.left)
                if node.right:
                    queue.append(node.right)
            
            result.append(level)

        return result[::-1]

 199. 二叉树的右视图

给定一个二叉树的 根节点 root，想象自己站在它的右侧，按照从顶部到底部的顺序，返回从右侧所能看到的节点值。

示例 1:

输入: [1,2,3,null,5,null,4]
输出: [1,3,4]
# 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 rightSideView(self, root: Optional[TreeNode]) -> List[int]:
        if not root:
            return []
        result = []
        queue = collections.deque([root])
        while queue:
            level = []
            for _ in range(len(queue)):
                cur = queue.popleft()
                level.append(cur.val)
                if cur.left:
                    queue.append(cur.left)
                if cur.right:
                    queue.append(cur.right)

            result.append(level[-1]) 
        return result

637. 二叉树的层平均值

给定一个非空二叉树的根节点 root , 以数组的形式返回每一层节点的平均值。与实际答案相差 10-5 以内的答案可以被接受。

示例 1：

输入：root = [3,9,20,null,null,15,7]
输出：[3.00000,14.50000,11.00000]
解释：第 0 层的平均值为 3,第 1 层的平均值为 14.5,第 2 层的平均值为 11 。
因此返回 [3, 14.5, 11] 。

 第一种方法：

# 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 averageOfLevels(self, root: Optional[TreeNode]) -> List[float]:
        res = []
        queue = collections.deque([root])
        while queue:
            level = []
            for _ in range(len(queue)):
                node = queue.popleft()
                level.append(node.val)
                if node.left:
                    queue.append(node.left)
                if node.right:
                    queue.append(node.right)
            level = sum(level) / len(level)
            res.append(level)

        return res

429. N 叉树的层序遍历

"""
# Definition for a Node.
class Node:
    def __init__(self, val: Optional[int] = None, children: Optional[List['Node']] = None):
        self.val = val
        self.children = children
"""

class Solution:
    def levelOrder(self, root: 'Node') -> List[List[int]]:
        if not root:
            return []
        res = []
        queue = collections.deque([root])
        while queue:
            level = []
            for _ in range(len(queue)):
                cur = queue.popleft()
                level.append(cur.val)
                if cur.children:
                    queue.extend(cur.children)
            res.append(level)
        
        return res

515. 在每个树行中找最大值

"""
# Definition for a Node.
class Node:
    def __init__(self, val: int = 0, left: 'Node' = None, right: 'Node' = None, next: 'Node' = None):
        self.val = val
        self.left = left
        self.right = right
        self.next = next
"""

class Solution:
    def connect(self, root: 'Optional[Node]') -> 'Optional[Node]':
        if not root:
            return root
        queue = collections.deque([root])
        while queue:
            prev = None
            for _ in range(len(queue)):
                cur = queue.popleft()

                if prev:
                    prev.next = cur
                prev = cur

                if cur.left:
                    queue.append(cur.left)
                if cur.right:
                    queue.append(cur.right)
        
        return root

116. 填充每个节点的下一个右侧节点指针 

"""
# Definition for a Node.
class Node:
    def __init__(self, val: int = 0, left: 'Node' = None, right: 'Node' = None, next: 'Node' = None):
        self.val = val
        self.left = left
        self.right = right
        self.next = next
"""

class Solution:
    def connect(self, root: 'Optional[Node]') -> 'Optional[Node]':
        if not root:
            return root
        queue = collections.deque([root])
        while queue:
            prev = None
            for _ in range(len(queue)):
                cur = queue.popleft()

                if prev:
                    prev.next = cur
                prev = cur

                if cur.left:
                    queue.append(cur.left)
                if cur.right:
                    queue.append(cur.right)
        
        return root

 117. 填充每个节点的下一个右侧节点指针 II

"""
# Definition for a Node.
class Node:
    def __init__(self, val: int = 0, left: 'Node' = None, right: 'Node' = None, next: 'Node' = None):
        self.val = val
        self.left = left
        self.right = right
        self.next = next
"""

class Solution:
    def connect(self, root: 'Node') -> 'Node':
        if not root:
            return root
        
        prev = None
        queue = collections.deque([root])
        while queue:
            prev = None
            for _ in range(len(queue)):
                cur = queue.popleft()
                
                if prev:
                    prev.next = cur
                prev = cur

                if cur.left:
                    queue.append(cur.left)
                if cur.right:
                    queue.append(cur.right)

        return root

 104. 二叉树的最大深度

# 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 maxDepth(self, root: Optional[TreeNode]) -> int:
        if not root:
            return 0
        count = 0
        queue = collections.deque([root])
        while queue:
            count += 1
            for _ in range(len(queue)):
                cur = queue.popleft()
                if cur.left:
                    queue.append(cur.left)
                if cur.right:
                    queue.append(cur.right)
                
        return count

 111. 二叉树的最小深度

# 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 minDepth(self, root: Optional[TreeNode]) -> int:
        if not root:
            return 0
        count = 0
        queue = collections.deque([root])
        while queue:

            count += 1
            
            for _ in range(len(queue)):
                cur = queue.popleft()
                if cur.left == None and cur.right == None:
                    return count
                if cur.left:
                    queue.append(cur.left)
                if cur.right:
                    queue.append(cur.right)
                
            
            

        return count
redohealer
关注
【代码随想录训练营】【Day14】第六章｜二叉树｜理论基础｜递归遍历｜迭代遍历｜统一迭代
士多啤梨先生の博客
02-14 2174
【代码随想录训练营】【Day14】第六章｜二叉树｜理论基础｜递归遍历｜迭代遍历｜统一迭代
Day16 二叉树的递归遍历，迭代遍历，层序遍历
2303_77739929的博客
12-22 1170
每次写递归，都要考虑三要素：1、确定递归函数的参数和返回值：哪些参数是递归的过程中要处理的，那么就在递归函数里加入这个参数，并且还要明确每次递归的返回值是什么进而确定递归函数的返回类型。2、确定终止条件。3、确定单层递归的逻辑：确定每一层递归需要处理的信息，就可以重复调用自己来实现递归。下面以前序遍历为例：2、确定终止条件：如果当前遍历的结点是空，那么本层递归就要结束了，代码如下；中序遍历和后序遍历只有单层递归的逻辑不同，其余都一样。
day13 二叉树递归遍历 迭代遍历 层序遍历
dindidne的博客
06-21 437
深度优先就是先遍历到叶子接点再返回，一般通过来实现，也可以转为迭代。深度优先的遍历方式主要是以区分，比如前序就是根左右，中序左根右，后续左右根。来完成。
day14 二叉树理论基础 递归遍历 迭代遍历 统一迭代
empowermentの博客
02-28 576
平衡二叉搜索树：又被称为AVL（Adelson-Velsky and Landis）树，且具有以下性质：它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。C++中map、set、multimap，multiset的底层实现都是平衡二叉搜索树，所以map、set的增删操作时间时间复杂度是logn。## 二叉树的存储方式 二叉树可以链式存储，也可以顺序存储。链式存储方式就用指针， 顺序存储的方式就是用数组。顺序存储的元素在内存是连续分布的，而链式存储则是通深度优先遍历
代码随想录训练营 Day13打卡 二叉树 part01 递归遍历 迭代遍历 层序遍历
qq_42952637的博客
07-29 1077
代码随想录训练营 Day13打卡 二叉树 part01 递归遍历 迭代遍历 层序遍历
Day11 | 二叉树 递归遍历 迭代遍历 统一迭代 层序遍历
q864508127的博客
07-15 583
在方法中先判断终止条件即节点不为空，因为是中序就左中右，先调用递归函数参数是左节点、ArrayList，再添加节点的值到ArrayList中，最后再调用递归函数参数是右节点、ArrayList。在循环里：先将根节点弹出，值放入数组中，判断如果右节点不为空放入右节点，再判断左节点，不为空把左节点放到栈中。依然采取栈的数据结构，我们将访问的节点放入栈中，把要处理的节点也放入栈中但是要做标记。判断节点是否为空，若不为空，将节点加入到栈中，节点向左子树遍历。首先创建一个数组，判断根节点是否为空，为空返回空数组。
Day.11 | 二叉树 递归遍历 迭代遍历 统一迭代 层序遍历
wizard_fire的博客
07-04 192
要点：确定递归的终止条件和需要传入的参数。
Day14 二叉树理论基础 递归遍历 迭代遍历 统一迭代
233
04-18 115
int val;} };
Day 14 理论基础 递归遍历 迭代遍历 统一迭代
qq_46025584的博客
04-02 370
int val;
代码随想录算法训练营第14天 | 二叉树理论基础 递归遍历 迭代遍历
lebowskii的博客
10-05 366
day 14
代码随想录算法训练营Day11 | 递归遍历，迭代遍历，统一迭代，层序遍历
little__penguin的博客
06-21 425
代码随想录算法训练营Day14|二叉树重点理论基础、递归遍历
m0_60979177的博客
12-20 1327
Day14打卡！今日感想：今天开启二叉树篇章！主要学习了递归法的遍历，之前学的有一点“浮于表面”，要注重学习基本逻辑，尽量把问题的根本理解透彻。
代码随想录Day14|递归遍历、迭代遍历、统一遍历
weixin_43399717的博客
05-24 348
后面在介绍图论的时候 还会介绍到。在深度优先遍历中：有三个顺序，前中后序遍历， 有同学总分不清这三个顺序，经常搞混，我这里教大家一个技巧。，只要大家记住 前中后序指的就是中间节点的位置就可以了。看如下中间节点的顺序，就可以发现，中间节点的顺序就是所谓的遍历方式。
代码随想录训练营第十四天 | 二叉树基础 递归遍历 144前序遍历 145后序遍历 94中序遍历
Sherry_Sky的博客
11-30 298
代码随想录训练营打卡Day14 | 二叉树基础 递归遍历 144前序遍历 145后序遍历 94中序遍历
数据结构与算法：高级数据结构与实际应用
最新发布
weidl001的博客
10-16 1116
本章介绍了跳表、Trie树、B树与 B+树等高级数据结构，以及它们在实际系统中的应用。这些数据结构在提高查找效率、优化存储和加速特定任务方面具有不可替代的作用。通过深入理解这些结构及其特性，我们能够选择最合适的数据结构来应对复杂的实际问题。在下一章中，我们将深入讨论并查集与线段树的高级应用，以及它们在图论和范围查询中的重要作用。
【数据结构】AVL树（C++实现）
weixin_73914025的博客
10-13 763
二叉搜索树虽可以缩短查找的效率，但如果数据有序或接近有序二叉搜索树将退化为单支树，查找元素相当于在顺序表中搜索元素，效率低下。当向二叉搜索树中插入新结点后，如果能保证每个结点的左右子树高度之差的绝对值不超过1(需要对树中的结点进行调整)，即可降低树的高度，从而减少平均搜索长度。它的左右子树都是AVL树左右子树高度之差(简称平衡因子)的绝对值不超过1(-1/0/1)如果一棵二叉搜索树是高度平衡的，它就是AVL树。如果它有n个结点，其高度可保持在Olog2nO(log_2 n)Olog。
《C++中栈的实现：探索高效数据结构》
xy520521的博客
10-13 607
当向栈中添加元素时，创建一个新的节点，将其数据设置为要添加的元素，并将其指向下一个节点设置为当前的栈顶节点，然后将栈顶指针指向新节点。当从栈中删除元素时，将栈顶指针指向当前栈顶节点的下一个节点，并释放原来栈顶节点的内存。首先，数组的大小是固定的，一旦栈的大小超过了数组的容量，就需要进行复杂的扩容操作。其次，数组实现的栈在内存中的分配是连续的，可能会导致内存碎片的问题。此外，链表实现的栈在内存中的分配是不连续的，不会产生内存碎片。但是，链表实现的栈在进行插入和删除操作时需要进行指针的操作，相对来说比较复杂。
数据结构——栈
2301_76227083的博客
10-14 724
简单介绍了栈是什么，以及如何用C语言实现一个栈
七大经典排序算法优化：插入排序、希尔排序、选择排序、冒泡排序、堆排序、快速排序、归并排序代码详解
weixin_64593595的博客
10-15 1738
本文深入探讨了七大经典排序算法的优化：插入排序、希尔排序、选择排序、冒泡排序、堆排序、快速排序和归并排序。适合需要稳定性排序的场景，通过对这些算法的分析和优化，能够根据具体需求选择合适的排序方法，从而提高程序性能和效率。
二叉树遍历基础与递归、迭代解法详解
总结来说，掌握二叉树的遍历方法是提高算法能力的关键，递归和迭代各有优势，递归简洁直观，而迭代则更利于空间复杂度的控制。理解了基本的前序、中序、后序遍历，其他遍历如层序遍历也就不难掌握了。在实际编程中，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值