数据结构与算法--二叉树遍历系列总结

最新推荐文章于 2024-04-07 23:10:02 发布
置顶 最新推荐文章于 2024-04-07 23:10:02 发布
阅读量202 收藏
点赞数
分类专栏： 数据结构 python 文章标签： 二叉树 算法 数据结构 leetcode
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_26884501/article/details/114283051
版权

目录

LeeCode题目

  1. 二叉树的前序遍历
  2. 二叉树的中序遍历
  3. 二叉树的后序遍历
  4. 二叉树的层序遍历
  5. N叉树的前序遍历

前提条件：构建树

# -*- coding: utf-8 -*-
"""
Created on Tue Mar  2 17:23:06 2021

@author: daicong
"""
# -*- coding: utf-8 -*-
"""
Created on Thu Feb 25 20:12:20 2021

@author: daicong
"""

class Node:
    """构建节点类"""
    def __init__(self,item):
        """二叉树的一个节点有三个参数元素、左子树、右子树"""
        self.item = item
        self.lchild = None
        self.rchild = None

class Tree:
    """构建树类"""
    def __init__(self,root=None):
        self.root = root
    
    def add(self,item):
        """添加节点"""
        node = Node(item)
        if self.root == None:
            """如果树为空，则添加的节点为根节点"""
            self.root = node
        else:
            queue = []
            """
            将树的每一个节点按照一层一层的放进去
            每次放进去的都是左子树或者右子树，一层一层的往下遍历
            """
            queue.append(self.root)
            while queue:
                cur = queue.pop(0)
                if cur.lchild == None:
                    """如果没有左子树，那么添加的节点为左子树"""
                    cur.lchild = node
                    return
                elif cur.rchild == None:
                    """如果没有右子树，那么添加的节点为右子树"""
                    cur.rchild = node
                    return
                else:
                    """如果左右子树都有，那么将左右子树放进队列中，一层一层的往下遍历，直到将节点加上去"""
                    queue.append(cur.lchild)
                    queue.append(cur.rchild)

1. 先序遍历

1.1 递归实现

"""方法1"""
class Solution:
    def preorderTraversal(self, root: TreeNode) -> List[int]:
        if not root:
            return []        
		 return [root.val] + self.preorderTraversal(root.left) + self.preorderTraversal(root.right)
"""方法2"""
class Solution:
    def preOrder(self, root: TreeNode) -> List[List[int]]:
        def dlr(root):
            if not root:
                return 
            res.append(root.val)
            dlr(root.lchild)
            dlr(root.rchild)
        res = []
        dlr(root)
        return res
"""参考"""
class Solution:
    def preOrder(self, root: TreeNode) -> List[List[int]]:
        if not root:
            return
        print(root.val)
        self.preOrder(root.lchild)
        self.preOrder(root.rchild)

1.2 迭代实现

class Solution:
    def preOrder(self, root: TreeNode) -> List[List[int]]:
        if not root:
            return 
        stack = [root]
        res=[]
        while stack:
            cur = stack.pop()
            res.append(cur.val)
            if cur.rchild:
                stack.append(cur.rchild)
            if cur.lchild:
                stack.append(cur.lchild)
        return res

2. 层序遍历

"""方法1"""
class Solution:
    def levelOrder(self, root: TreeNode) -> List[List[int]]:
        if not root:
            return
        queue = [root]
        res = []
        while queue:
        	"""定义两个列表分别存储节点和值"""
            lay,layval = [],[]
            for node in queue:
                layval.append(node.val)
                if node.lchild:
                    lay.append(node.lchild)
                if node.rchild:
                    lay.append(node.rchild)
            queue = lay
            res.append(layval)
        return res
"""
[[0], [1, 2], [3, 4, 5, 6], [7, 8, 9]]              
"""  

"""参考"""
class Solution:
    def levelOrder(self, root: TreeNode) -> List[List[int]]:
        if not root:
            return
        queue = [root]
        while queue:
            cur = queue.pop(0)
            print(cur.val)
            if cur.lchild:
                queue.append(cur.lchild)
            if cur.rchild:
                queue.append(cur.rchild)

3. N叉树前序遍历

"""
# Definition for a Node.
class Node(object):
    def __init__(self, val=None, children=None):
        self.val = val
        self.children = children
"""

class Solution(object):
    def preorder(self, root):
        """
        :type root: Node
        :rtype: List[int]
        """
        if not root:
            return []
        res = [root.val]
        for node in root.children:
            res += self.preorder(node)
        return res

主要参考资料：

LeetCode官方题解
powcai的题解
Annie Kim’s Blog
维基百科对于线索二叉树的解释
莫里斯的文章

代码实现

  • 这里分别给出了三种二叉树的遍历方法与N叉树的前序遍历，及其时空复杂度
    1：递归：直接递归版本、针对不同题目通用递归版本（包括前序、中序、后序）
    2：迭代：最常用版本（常用主要包括前序和层序，即【DFS和BFS】）、【前中后】序遍历通用版本（一个栈的空间）、【前中后层】序通用版本（双倍栈（队列）的空间）
    3：莫里斯遍历：利用线索二叉树的特性进行遍历
    4：N叉树的前序遍历
# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None



# 递归
# 时间复杂度：O(n)，n为节点数，访问每个节点恰好一次。
# 空间复杂度：空间复杂度：O(h)，h为树的高度。最坏情况下需要空间O(n)，平均情况为O(logn)

# 递归1：二叉树遍历最易理解和实现版本
class Solution:
    def preorderTraversal(self, root: TreeNode) -> List[int]:
        if not root:
            return []
        # 前序递归
        return [root.val] + self.preorderTraversal(root.left) + self.preorderTraversal(root.right)
        # # 中序递归 
        # return self.inorderTraversal(root.left) + [root.val] + self.inorderTraversal(root.right)
        # # 后序递归
        # return self.postorderTraversal(root.left) + self.postorderTraversal(root.right) + [root.val]

# 递归2：通用模板，可以适应不同的题目，添加参数、增加返回条件、修改进入递归条件、自定义返回值
class Solution:
    def preorderTraversal(self, root: TreeNode) -> List[int]:
        def dfs(cur):
            if not cur:
                return      
            # 前序递归
            res.append(cur.val)
            dfs(cur.left)
            dfs(cur.right) 
            # # 中序递归
            # dfs(cur.left)
            # res.append(cur.val)
            # dfs(cur.right)
            # # 后序递归
            # dfs(cur.left)
            # dfs(cur.right)
            # res.append(cur.val)      
        res = []
        dfs(root)
        return res



# 迭代
# 时间复杂度：O(n)，n为节点数，访问每个节点恰好一次。
# 空间复杂度：O(h)，h为树的高度。取决于树的结构，最坏情况存储整棵树，即O(n)

# 迭代1：前序遍历最常用模板（后序同样可以用）
class Solution:
    def preorderTraversal(self, root: TreeNode) -> List[int]:
        if not root:
            return []        
        res = []
        stack = [root]
        # # 前序迭代模板：最常用的二叉树DFS迭代遍历模板
        while stack:
            cur = stack.pop()
            res.append(cur.val)
            if cur.right:
                stack.append(cur.right)
            if cur.left:
                stack.append(cur.left)
        return res
        
        # # 后序迭代，相同模板：将前序迭代进栈顺序稍作修改，最后得到的结果反转
        # while stack:
        #     cur = stack.pop()
        #     if cur.left:
        #         stack.append(cur.left)
        #     if cur.right:
        #         stack.append(cur.right)
        #     res.append(cur.val)
        # return res[::-1]

# 迭代1：层序遍历最常用模板
class Solution:
    def levelOrder(self, root: TreeNode) -> List[List[int]]:
        if not root:
            return []
        cur, res = [root], []
        while cur:
            lay, layval = [], []
            for node in cur:
                layval.append(node.val)
                if node.left: lay.append(node.left)
                if node.right: lay.append(node.right)
            cur = lay
            res.append(layval)
        return res

        
        
# 迭代2：前、中、后序遍历通用模板（只需一个栈的空间）
class Solution:
    def inorderTraversal(self, root: TreeNode) -> List[int]: 
        res = []
        stack = []
        cur = root
        # 中序，模板：先用指针找到每颗子树的最左下角，然后进行进出栈操作
        while stack or cur:
            while cur:
                stack.append(cur)
                cur = cur.left
            cur = stack.pop()
            res.append(cur.val)
            cur = cur.right
        return res
        
        # # 前序，相同模板
        # while stack or cur:
        #     while cur:
        #         res.append(cur.val)
        #         stack.append(cur)
        #         cur = cur.left
        #     cur = stack.pop()
        #     cur = cur.right
        # return res
        
        # # 后序，相同模板
        # while stack or cur:
        #     while cur:
        #         res.append(cur.val)
        #         stack.append(cur)
        #         cur = cur.right
        #     cur = stack.pop()
        #     cur = cur.left
        # return res[::-1]
        


# 迭代3：标记法迭代（需要双倍的空间来存储访问状态）：
# 前、中、后、层序通用模板，只需改变进栈顺序或即可实现前后中序遍历，
# 而层序遍历则使用队列先进先出。0表示当前未访问，1表示已访问。
class Solution:
    def preorderTraversal(self, root: TreeNode) -> List[int]:
        res = []
        stack = [(0, root)]
        while stack:
            flag, cur = stack.pop()
            if not cur: continue
            if flag == 0:
                # 前序，标记法
                stack.append((0, cur.right))
                stack.append((0, cur.left))
                stack.append((1, cur))
                
                # # 后序，标记法
                # stack.append((1, cur))
                # stack.append((0, cur.right))
                # stack.append((0, cur.left))
                
                # # 中序，标记法
                # stack.append((0, cur.right))
                # stack.append((1, cur))
                # stack.append((0, cur.left))  
            else:
                res.append(cur.val)  
        return res
        
        # # 层序，标记法
        # res = []
        # queue = [(0, root)]
        # while queue:
        #     flag, cur = queue.pop(0)  # 注意是队列，先进先出
        #     if not cur: continue
        #     if flag == 0:
                  # 层序遍历这三个的顺序无所谓，因为是队列，只弹出队首元素
        #         queue.append((1, cur))
        #         queue.append((0, cur.left))
        #         queue.append((0, cur.right))
        #     else:
        #         res.append(cur.val)
        # return res



# 莫里斯遍历
# 时间复杂度：O(n)，n为节点数，看似超过O(n)，有的节点可能要访问两次，实际分析还是O(n)，具体参考大佬博客的分析。
# 空间复杂度：O(1)，如果在遍历过程中就输出节点值，则只需常数空间就能得到中序遍历结果，空间只需两个指针。
# 如果将结果储存最后输出，则空间复杂度还是O(n)。

# PS：莫里斯遍历实际上是在原有二叉树的结构基础上，构造了线索二叉树，
# 线索二叉树定义为：原本为空的右子节点指向了中序遍历顺序之后的那个节点，把所有原本为空的左子节点都指向了中序遍历之前的那个节点
# emmmm，好像大学教材学过，还考过

# 此处只给出中序遍历，前序遍历只需修改输出顺序即可
# 而后序遍历，由于遍历是从根开始的，而线索二叉树是将为空的左右子节点连接到相应的顺序上，使其能够按照相应准则输出
# 但是后序遍历的根节点却已经没有额外的空间来标记自己下一个应该访问的节点，
# 所以这里需要建立一个临时节点dump，令其左孩子是root。并且还需要一个子过程，就是倒序输出某两个节点之间路径上的各个节点。
# 具体参考大佬博客

# 莫里斯遍历，借助线索二叉树中序遍历（附前序遍历）
class Solution:
    def inorderTraversal(self, root: TreeNode) -> List[int]:
        res = []
        # cur = pre = TreeNode(None)
        cur = root

        while cur:
            if not cur.left:
                res.append(cur.val)
                # print(cur.val)
                cur = cur.right
            else:
                pre = cur.left
                while pre.right and pre.right != cur:
                    pre = pre.right
                if not pre.right:
                    # print(cur.val) 这里是前序遍历的代码，前序与中序的唯一差别，只是输出顺序不同
                    pre.right = cur
                    cur = cur.left
                else:
                    pre.right = None
                    res.append(cur.val)
                    # print(cur.val)
                    cur = cur.right
        return res



# N叉树遍历
# 时间复杂度：时间复杂度：O(M)，其中 M 是 N 叉树中的节点个数。每个节点只会入栈和出栈各一次。
# 空间复杂度：O(M)。在最坏的情况下，这棵 N 叉树只有 2 层，所有第 2 层的节点都是根节点的孩子。
# 将根节点推出栈后，需要将这些节点都放入栈，共有 M−1个节点，因此栈的大小为 O(M)。


"""
# Definition for a Node.
class Node:
    def __init__(self, val=None, children=None):
        self.val = val
        self.children = children
"""

# N叉树简洁递归
class Solution:
    def preorder(self, root: 'Node') -> List[int]:
        if not root: return []
        res = [root.val]
        for node in root.children:
            res.extend(self.preorder(node))
        return res

# N叉树通用递归模板
class Solution:
    def preorder(self, root: 'Node') -> List[int]:
        res = []
        def helper(root):
            if not root:
                return
            res.append(root.val)
            for child in root.children:
                helper(child)
        helper(root)
        return res

# N叉树迭代方法
class Solution:
    def preorder(self, root: 'Node') -> List[int]:
        if not root:
            return []
        s = [root]
        # s.append(root)
        res = []
        while s:
            node = s.pop()
            res.append(node.val)
            # for child in node.children[::-1]:
            #     s.append(child)
            s.extend(node.children[::-1])
        return res
望长安于日下
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构——二叉树遍历和常见问题
weixin_57133901的博客
04-22 3197
二叉树遍历 二叉树常见问题
[算法] 二叉树的 先序遍历、中序遍历、后序遍历
热门推荐
scxyz的博客
02-27 3万+
本文根据清华大学邓俊辉老师课程《数据结构》总结，课程地址 。 遍历介绍 按照事先约定的某种规则或次序，对节点各访问一次而且仅一次。与向量和列表等线性结构一样，二叉树的这类访问也统称为遍历（traversal）。 二叉树本身并不具有天然的全局次序， 故为实现遍历，需通过在各节点与其孩子之间约定某种局部次序， 间接地定义某种全局次序。 按惯例左兄弟优先于右兄弟， 若记做节点 V ，...
leetcode 左程云笔记
Blue_Whale2020的博客
02-13 1758
P5 二叉树 0：0：53 两链表相交问题：可能有环可能无环，要求时间复杂度o（n） 4：42 判断一个链表是否有环的方法： 使用哈希表：每到一个节点就查询节点在不在哈希表里，不在就添加在表中 12：21快慢指针法 快指针如果指向null，那么链表无环，如果有环，快慢指针会在环上相遇 20：56 解决了两个链表各自有没有环这个问题之后，开始解决链表相交问题 25：33 如果两个链表的结尾不相同，那两个链表一定不会相交，因为不会有类似“X”形状的分叉结构 28：40 链表1无环 链表2无环
二叉树层次遍历通用模板公式
IRON_MAN_LEVEL1的博客
11-30 870
二叉树遍历，层次遍历通用模板公式
算法22：二叉树各种算法——万能模板
街头小瘪三的专栏
02-23 382
二叉树算法的固定模板
数据结构课程设计报告-二叉树的遍历.docx
03-07
数据结构课程设计报告-二叉树的遍历 本报告基于二叉树的遍历方法，旨在通过递归和非递归两种方法创建一棵二叉树，并对其进行先序遍历、中序遍历、后序遍历及层次遍历，并求出该二叉树的深度和叶子结点数。同时，...
数据结构实验报告6-树-二叉树的遍历算法-实验内容及要求.docx
07-06
编写程序，用先序递归遍历法建立二叉树的二叉链表存储结构，然后输出其先序、中序、后序以及层次遍历结点访问次序。其中层次遍历的实现需使用循环队列。二叉树结点数据类型建议选用字符类型
数据结构课程设计--二叉树的遍历.docx
10-10
数据结构课程设计--二叉树的遍历 在计算机科学中，数据结构是指计算机中组织和存储数据的方式。二叉树是一种非常重要的非线性结构，所描述的数据有明显的层次关系，其中的每个元素只有一个前驱。在计算机科学中，...
数据结构与算法-二叉树的排序
最新发布
05-08
用递归的方法实现以下算法： 1．以二叉链表表示二叉树，建立一棵二叉树； 2．输出二叉树的中序遍历结果； 3．输出二叉树的前序遍历结果； 4．输出二叉树的后序遍历结果； 5．计算二叉树的深度； 6．统计二叉树的结点...
算法-数据结构和算法-17-二叉树的广度优先遍历和二叉树节点插入操作.rar
09-16
在提供的"数据结构和算法-17-二叉树的广度优先遍历和二叉树节点插入操作.pdf"文件中，你可能会找到关于这些主题的详细解释，包括具体算法的伪代码、示例以及可能的实现。通过深入学习和理解这些内容，你可以提升在...
二叉树模版
01-19
各类和二叉树有关的模版，binary_tree、huffman_tree、in_thread_binary_tree、sq_binary_tree
二叉树模板 各种函数
12-17
二叉树的模板，可以实现二叉树的各种运算，数组存储
二叉树模板
心如冰清，天塌不惊
10-17 238
二叉树模板
二叉树-C++模板类
Zou_Cuo的博客
04-07 252
本文为二叉树C++模板类的“学习”代码，其中含构造、析构、插入、前序、中序‘后序遍历’等等。
树的概念、性质、存储、遍历
weixin_64840732的博客
06-01 137
基本概念： 树是n（n≥0）个结点的有限集合T(Tree)。当n=0时，称为空树；当n>0时， 该集合满足如下条件： (1) 其中必有一个称为根（root）的特定结点，它没有直接前驱，但有零个或多个直接后继。 (2) 其余n-1个结点可以划分成m（m≥0）个互不相交的有限集T1，T2，T3，…，Tm，其中Ti又是一棵树，称为根root的子树。 每棵子树的根结点有且仅有一个直接前驱，但有零个或多个直接后继。 结点：包含一个数据元素及若干指向其它结点的分支信息。 结点的度：一个结点的子树个数称为此结点的度。
二叉树类模版及各种函数操作
qq_51802524的博客
11-06 293
有需要的小伙伴可以借鉴代码思路，但是不要copy～ main函数 随便调试的函数，大家根据需要自己调试函数哈～ #include "BiTree.cpp" #include <iostream> using namespace std; #define NodesLength 27 int main(int argc, const char * argv[]) { // char preOrder[NodesLength] = {'A', 'B', 'D', 'C',
二叉树的模板类实现
CodeCAT
03-20 7222
二叉树的定义 二叉树（Binary Tree）是n>0个结点的有限集合，该集合或者为空集（称为空二叉树），或者由一个根节点和两棵不相交的分别被称为左子树和右子树组成。·不存在度大于2的结点； ·左右子树是有序的，次序不能任意的颠倒。 二叉树的链表存储方式 二叉树的每个结点最多有两个孩子，所以设计一个数据域和两个指针域，我们称为二叉链表。 二叉链树的结点定义为template<typenam
刷题常用的二叉树代码模板
qq_39256469的博客
08-28 110
ACM模式下刷二叉树的题目常用的代码模板

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值