代码随想录算法训练营day14 | 二叉树理论基础，递归遍历，迭代遍历，统一迭代法

已于 2022-10-07 11:38:01 修改
阅读量435 收藏
点赞数
文章标签： 数据结构 算法 深度优先 迭代加深 leetcode
于 2022-10-06 07:08:17 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jzh013/article/details/127166005
版权

二叉树理论基础：

  1. https://www.bilibili.com/video/BV1Hy4y1t7ij
  2. 代码随想录
class TreeNode(object):
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right

递归遍历

  • 递归三部曲：

    1. 确定递归函数的参数和返回值

    2. 确定终止条件

    3. 确定单层递归的逻辑

  • 144. 二叉树的前序遍历-preorder traversal 

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    def preorderTraversal(self, root): #step1
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        #step2
        if root == None:
            return []
        #step3
        return [root.val]+self.preorderTraversal(root.left)+self.preorderTraversal(root.right)
# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    def preorderTraversal(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        res = []
        
        def traversal(root): #step1: parameter and return type
            #step2: base condition
            if root is None:
                return res
            
            #step3: logic
            res.append(root.val)
            traversal(root.left)
            traversal(root.right)
            
        traversal(root)
        return res

  • 145. 二叉树的后序遍历-postorder traversal

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    def postorderTraversal(self, root): #step1
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        #step2
        if root == None:
            return []
        #step3
        return self.postorderTraversal(root.left)+self.postorderTraversal(root.right)+[root.val]
# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    def postorderTraversal(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        res = []
        
        def traversal(root): #step1: parameter and return type
            #step2: base condition
            if root is None:
                return res
            
            #step3: logic
            traversal(root.left)
            traversal(root.right)
            res.append(root.val)
            
        traversal(root)
        return res

  • 94. 二叉树的中序遍历-inorder traversal

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    def inorderTraversal(self, root): #step 1
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        #step2
        if root is None:
            return []
        #step3
        return self.inorderTraversal(root.left)+[root.val]+self.inorderTraversal(root.right)
        
# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    def inorderTraversal(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        res = []
        
        def traversal(root): #step1: parameter and return type
            #step2: base condition
            if root is None:
                return res
            
            #step3: logic
            traversal(root.left)
            res.append(root.val)
            traversal(root.right)
            
        traversal(root)
        return res

迭代遍历

  • trick：深度优先遍历借助栈，层序优先遍历借助队列

  • 144. 二叉树的前序遍历-preorder traversal 

    • 前序遍历是中左右，那么在用栈的时候就需要先放入右子树，然后左子树，这样在pop的时候就是左子树先出。
# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    def preorderTraversal(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        ans = []
        stack = [root] #初始化需要将root传入，也就是把二叉树传进来；注意：stack存的是指针
        
        if root is None:
            return ans
        
        while stack:
            node = stack.pop()
            #中
            ans.append(node.val)
            #右
            if node.right:
                stack.append(node.right)
            #左
            if node.left:
                stack.append(node.left)
                
        return ans

  • 145. 二叉树的后序遍历-postorder traversal

    • 后序遍历是左右中，那么为了尽量让代码统一，则思考如何在前序遍历的基础来改动。因此，（前序）中左右 --> 中右左 --> 反转 --> 左右中（后序）
# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    def postorderTraversal(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        ans = []
        stack = [root] #初始化需要将root传入，也就是把二叉树传进来；注意：stack存的是指针
        
        if root is None:
            return ans
        
        while stack:
            node = stack.pop()
            #中
            ans.append(node.val)
            #左
            if node.left:
                stack.append(node.left)
            #右
            if node.right:
                stack.append(node.right)
                
        return ans[::-1]

  •  94. 二叉树的中序遍历-inorder traversal

    • 注意访问（遍历）以及处理（将元素放进结果集）的顺序
# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    def inorderTraversal(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        ans = []
        stack =[] #注意：不可初始化的时候传入root，因为顺序是左中右
        curr = root 
        
        if root is None:
            return ans
        
        while curr or stack:
            # 先迭代访问最底层的左子树结点
            if curr:
                stack.append(curr) # 栈就是记录指针访问过的元素，但是需要注意的是栈依旧是存的指针！
                curr =curr.left
            # 到达最左结点后处理栈顶结点  
            else:
                curr = stack.pop()
                ans.append(curr.val) 
                curr = curr.right
                
        return ans

二叉树的统一迭代法

  • 暂时略过

总结：

  • 注意二叉树的定义，基础还要反复看

  • 递归法的三步：从简单的练习

  • 迭代法：前中后序如何利用栈来遍历。

  • 深度优先用栈，广度优先用队列

jzh013
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C语言实现二叉树遍历的迭代算法
09-04
主要介绍了C语言实现二叉树遍历的迭代算法,包括二叉树的中序遍历、先序遍历及后序遍历等,是非常经典的算法,需要的朋友可以参考下
C语言数据结构之二叉树的非递归后序遍历算法
01-01
前序、中序、后序的非递归遍历中，要数后序最为麻烦，如果只在栈中保留指向结点的指针，那是不够的，必须有一些额外的信息存放在栈中。 方法有很多，这里只举一种，先定义栈结点的数据结构 typedef struct{Node *...
代码随想录算法训练营Day14 | 二叉树理论基础、递归遍历、迭代遍历、统一迭代
ckw_lztxdy的博客
02-06 386
int value;
代码随想录算法训练营Day 14|二叉树Part01|二叉树理论基础、递归遍历 、迭代遍历、统一迭代
m0_51759998的博客
04-03 901
前面介绍的树，都没有数值的，而二叉搜索树是有数值的了，二叉搜索树是一个有序树。下面这两棵树都是搜索树 又被称为AVL（Adelson-Velsky and Landis）树，且具有以下性质：它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。 常用 通过指针把分布在各个地址的节点串联一起。 如果父节点的数组下标是 i，那么它的左孩子就是 i * 2 + 1，右孩子就是 i * 2 + 2。 递归遍历 二叉树的前序遍历 二叉树的中序遍历 二叉树的后序遍历每次写递归，
代码随想录算法训练营day14｜理论基础，递归遍历，迭代遍历，统一迭代
weixin_52121600的博客
11-08 314
二叉树day1
代码随想录算法训练营Day14|理论基础● 递归遍历 ● 迭代遍历● 统一迭代
2401_82757749的博客
06-04 274
从今天开始正式进入到二叉树章节，因为今天的内容我在学校就已经全部学过了，所以今天就是简单的说一下，题目就不放上来了，都是简单的二叉树的前中后序遍历的递归写法和迭代写法； 递归写法不用多说，来看迭代的具体代码 vector<int> preorderTraversal(TreeNode* root) { if(root==NULL) return {}; vector<int> vec; stack<TreeNode*> st;
代码随想录算法训练营 Day 14 | 二叉树理论基础，递归遍历，迭代遍历
MisakaMirai的博客
04-18 121
第一次理解二叉树的遍历。。
代码随想录算法训练营day14|二叉树的递归遍历、二叉树的迭代遍历、二叉树的统一迭代法
github_35852648的博客
05-21 681
首先需要明确的一点是，前序中序和后序在二叉树的递归遍历中的区别仅在于递归函数中操作的顺序，前序是在遍历一个节点的左右子树前进行操作，中序是在遍历一个节点的左子树后进行操作再遍历右子树，而后序是在遍历完左右子树再进行操作。所以在递归函数中，仅是顺序的差别。
代码随想录算法训练营第14天 | 二叉树理论基础 递归遍历 迭代遍历
lebowskii的博客
10-05 278
day 14
代码随想录算法训练营Day14| 二叉树递归遍历、 迭代遍历、统一迭代
wuhuqifei123的博客
12-20 152
代码随想录算法训练Day 14
代码随想录算法训练营day14 | 二叉树的递归遍历、二叉树的迭代遍历、二叉树的统一迭代
weixin_69675605的博客
03-07 849
LeetCode | 144 二叉树的前序遍历、145.二叉树的后序遍历、94.二叉树的中序遍历
深入理解二叉树的非递归遍历
09-05
本篇文章是对二叉树的非递归遍历进行了详细的分析介绍，需要的朋友参考下
二叉树遍历 非递归 C++实现代码
01-01
二叉树的非递归遍历 二叉树是一种非常重要的数据结构，很多其它数据结构都是基于二叉树的基础演变而来的。对于二叉树，有前序、中序以及后序三种遍历方法。因为树的定义本身就是递归定义，因此采用递归的方法去实现...
C语言二叉树的非递归遍历实例分析
09-04
主要介绍了C语言二叉树的非递归遍历,包括了先序遍历、中序遍历与后序遍历,需要的朋友可以参考下
数据结构之B树
嫦娥妹妹等等我的博客
06-16 324
**节点的大小**：每个节点至少有 `t - 1` 个键值（除根节点外），最多有 `2t - 1` 个键值。1. **高效的磁盘读取**：由于每个节点包含多个键值和指针，B树减少了磁盘I/O操作的次数，提高了查找和更新的效率。- **数据库系统**：B树及其变种（如B+树、B*树）广泛用于数据库索引结构，支持快速的数据插入、删除和查询。- 每个节点最多有 `2t - 1` 个键值和 `2t` 个子节点指针，其中 `t` 是B树的最小度数。- **平衡性**：B树是一棵平衡树，所有叶子节点位于同一层。
数据结构：冒泡排序，选择排序，插入排序，希尔排序的实现分析
Zhihuiguoz的博客
06-16 681
这篇博客主要介绍了一些基本的排序算法，从算法思想，算法步骤，动图演示，代码实现，复杂度分析，稳定性分析这几个方面详细的介绍了冒泡排序，选择排序，插入排序，希尔排序的运用。并对其进行了优化实现，简单易懂，很好上手。
排序——希尔排序
2301_80662872的博客
06-16 378
当序列越有顺序时，插入排序的时间效率就越高。时间复杂度：O(N^2)（虽然时间复杂度是N^2，那是在逆序的序列情况下，在现实中这种情况一般不会出现）空间复杂度：O(1)gap＞1：预排序，目的是让序列变得更有序。时间复杂度：O(N^1.3)空间复杂度：O(1)
北航第六次数据结构与程序设计作业（查找与排序）选填题
最新发布
zxy13149285776的博客
06-16 542
但是我们可以根据满二叉树h=log（n+1）大概估计一下，如果是三层的满二叉树，那么n为7，如果是4层的满二叉树，则n为15。的次数，而不是18交换的次数，18先和10比较，发现18比10大。从arr[1]到arr[n-1]，如果本身就递增，那么每个元素只跟自己的直接前驱元素比较一次就行，那么比较了n-1次。发生冲突，说明余数一致，说明能整除，放眼观去，63,9,45都能整除，因此3个和18冲突。看好了，是在序列中的位置，不是下标，位置从1开始，下标从0开始。若查找一个不存在的元素，说明进行了深度次比较。
代码随想录刷题训练营DAY 15 二叉树 Part 02 | 102. 二叉树的层序遍历 107. 二叉树的层序遍历 Ⅱ 226. 反转二叉树 101. 对称二叉树---火腿
09-23
引中提到，二叉树的层序遍历可以通过DFS或BFS来实现。其中，BFS是利用队列的先进先出特性来实现的，每一层的节点被依次加入队列中，然后逐个出队并将其子节点加入队列。 引用中给出了一个实现翻转二叉树的代码示例。该代码使用了递归法的前序遍历，对于每一个节点，交换其左右子节点，然后递归地对其左右子树进行翻转。 引用中给出了一个实现二叉树的层序遍历的代码示例。该代码使用了BFS的思想，借助队列来实现层序遍历。每一层的节点被依次加入队列中，然后逐个出队并将其子节点加入队列，同时将当前层的节点值添加到结果列表中。 综上所述，参考这些引用，可以通过BFS来实现二叉树的层序遍历，并通过递归法或迭代法来翻转二叉树。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值