算法基础之二叉树理论

最新推荐文章于 2024-09-18 22:23:06 发布
最新推荐文章于 2024-09-18 22:23:06 发布
阅读量275 收藏
点赞数
分类专栏： 算法基础 文章标签： python 算法 数据结构 二叉树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Buluchacha/article/details/120548086
版权
本文深入探讨了树的基础概念，包括结点度、结点关系以及森林的定义。特别关注了二叉树的特性，如满二叉树和完全二叉树的定义，并详细介绍了二叉树的链式和顺序存储方法。此外，还阐述了二叉树的基本操作，如插入结点的算法以及深度优先和广度优先遍历的实现，包括前序、中序和后序遍历。最后，通过示例展示了不同遍历方法的输出结果。
摘要由CSDN通过智能技术生成

算法基础之二叉树理论

1.树基础

官方定义:树是n(n>=0)个结点的有限集。在任意一棵非空树中：

  • 有且仅有一个特定的被称为根（Root）的结点
  • 当n>1时，其余结点可分为m（m>0）个互不相交的有限集T1，T2，…，Tm，其中每一个集合本身又是一棵树，并且称为根的子树（SubTree）

解释：
树是一种以层次化方式组织和存放数据的特定数据结构。树有两个主要特征：

  • 每个项都有多个子节点
  • 除了叫做根的特殊的项，所有其他的项都只有一个父节点

在这里插入图片描述
在这里插入图片描述
结点分类：

  • 结点的度(Degree)：结点拥有的子树数称为结点的度。度为0的结点称为叶子（Leaf）或终端结点。度不为0的结点称为非终端结点或分支结点
  • 树的度：是树内各结点的度的最大值

结点间关系：

  • 孩子和双亲：结点的子树的根称为该结点的孩子（Child），相应地，该结点称为孩子的双亲（Parent）
  • 兄弟：同一个双亲的结点的孩子之间互称兄弟

结点的层次（Level）：是从根结点开始计算起，根为第一层，根的孩子为第二层，依次类推。树中结点的最大层次称为树的深度（Depth）或高度

如果将树中结点的各子树看成从左至右是有次序的（即不能互换），则称该树为有序树，否则称为无序树。

森林：由m(m>=0)棵互不相交的树组成的集合

2.二叉树基础

官方定义：二叉树是n个结点的有限集合，该集合或者为空集，或者由一个根结点和两棵互不相交的、分别称为根结点的左子树和右子树的二叉树组成

解释： 二叉树（Binary Tree）是一种特殊的树型结构，它的特点是每个结点至多有两棵子树，且二叉树的子树有左右之分，其次序不能任意颠倒

在这里插入图片描述
思考：只有三个结点的树有多少种形态？
在这里插入图片描述
特殊的二叉树：

  • 满二叉树：

在这里插入图片描述

  • 完全二叉树：

    对一棵具有n个结点的二叉树按层序编号，如果编号为i的结点与同样深度的满二叉树中编号结点为 i的结点在二叉树中位置完全相同，则这棵二叉树成为完全二叉树
    其特点为：

    • 叶子结点只能出现在最下两层
    • 最下层的叶子一定集中在左部连续位置
    • 倒数二层，若有叶子结点，一定都在右部连续位置
    • 如果结点度为1，则该结点只有左孩子，即不存在只有右子树的情况
    • 同样结点数的二叉树，完全二叉树的深度最小

在这里插入图片描述
二叉树性质：
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
二叉树的存储方式：

  • 链式存储：

在这里插入图片描述

  • 顺序存储：

在这里插入图片描述

3.二叉树基本操作

class Node(object):
    def __init__(self, item):
        self.item = item
        self.left = None #左结点指针
        self.right = None #右结点指针

    def __str__(self): #方便打印
        return str(self.item)
    
class Tree(object):
    def __init__(self):
        # 根节点定义为 root 永不删除，做为哨兵使用。
        self.root = Node('root')

3.1插入结点

插入一个元素（逐层向下插入）:
在这里插入图片描述

 def add(self, item):
        node = Node(item)
        if self.root is None: #边界条件
            self.root = node
        else:
            q = [self.root] #队列：先进先出

            while True:
                pop_node = q.pop(0)
                if pop_node.left is None:
                    pop_node.left = node
                    return
                elif pop_node.right is None:
                    pop_node.right = node
                    return
                else: 
                    q.append(pop_node.left)
                    q.append(pop_node.right)

3.2二叉树遍历

二叉树的遍历，指的是如何按某种搜索路径巡防树中的每个结点，使得每个结点均被访问一次，而且仅被访问一次。
⼆叉树主要有两种遍历⽅式：

  • 深度优先遍历：先往深⾛，遇到叶⼦节点再往回⾛。
  • ⼴度优先遍历：⼀层⼀层的去遍历。

3.2.1 深度优先遍历

  • 前序遍历：根-左-右
    操作定义为：若二叉树为空，为空操作；否则（1）访问根节点；（2）先序遍历左子树；（3）先序遍历右子树。

在这里插入图片描述

 def preorder(self, root):  # 先序遍历
        if root is None:
            return []
        result = [root.item]
        left_item = self.preorder(root.left)  #递归调用
        right_item = self.preorder(root.right)
        return result + left_item + right_item #根结点 左子树结点 右子树结点
  • 中序遍历：左-根-右
    操作定义为：若二叉树为空，为空操作；否则（1）中序遍历左子树；（2）访问根结点；（3）中序遍历右子树。

在这里插入图片描述

def inorder(self, root):  # 中序序遍历
        if root is None:
            return []
        result = [root.item]
        left_item = self.inorder(root.left)
        right_item = self.inorder(root.right)
        return left_item + result + right_item #左 根 右
  • 后序遍历：左-右-根
    操作定义为：若二叉树为空，为空操作；否则（1）后序遍历左子树；（2）后序遍历右子树；（3）访问根结点。

在这里插入图片描述

def postorder(self, root):  # 后序遍历
        if root is None:
            return []
        result = [root.item]
        left_item = self.postorder(root.left)
        right_item = self.postorder(root.right)
        return left_item + right_item + result #左 右 根

总结:
在这里插入图片描述

3.2.2 广度优先遍历

  • 层序遍历：
    操作定义为：若二叉树为空，为空操作；否则从上到下、从左到右按层次进行访问。

在这里插入图片描述

def traverse(self):  # 层次遍历
        if self.root is None:
            return None
        q = [self.root]
        res = [self.root.item]
        while q != []:
            pop_node = q.pop(0)
            if pop_node.left is not None:
                q.append(pop_node.left)
                res.append(pop_node.left.item)

            if pop_node.right is not None:
                q.append(pop_node.right)
                res.append(pop_node.right.item)
        return res

测试一下：

if __name__ == '__main__':
    t = Tree()
    for i in range(10): #10个结点
        t.add(i)
    print('层序遍历:', t.traverse())
    print('先序遍历:', t.preorder(t.root))
    print('中序遍历:', t.inorder(t.root))
    print('后序遍历:', t.postorder(t.root))


层序遍历: ['root', 0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
先序遍历: ['root', 0, 2, 6, 7, 3, 8, 9, 1, 4, 5]
中序遍历: [6, 2, 7, 0, 8, 3, 9, 'root', 4, 1, 5]
后序遍历: [6, 7, 2, 8, 9, 3, 0, 4, 5, 1, 'root']

总的程序如下：

#二叉树操作

class Node(object):
    def __init__(self, item):
        self.item = item
        self.left = None #左结点指针
        self.right = None #右结点指针

    def __str__(self): #方便打印
        return str(self.item)
    
class Tree(object):
    def __init__(self):
        # 根节点定义为 root 永不删除，做为哨兵使用。
        self.root = Node('root')

    def add(self, item):
        node = Node(item)
        if self.root is None: #边界条件
            self.root = node
        else:
            q = [self.root] #队列：先进先出

            while True:
                pop_node = q.pop(0)
                if pop_node.left is None:
                    pop_node.left = node
                    return
                elif pop_node.right is None:
                    pop_node.right = node
                    return
                else: 
                    q.append(pop_node.left)
                    q.append(pop_node.right)

    

    def traverse(self):  # 层次遍历
        if self.root is None:
            return None
        q = [self.root]
        res = [self.root.item]
        while q != []:
            pop_node = q.pop(0)
            if pop_node.left is not None:
                q.append(pop_node.left)
                res.append(pop_node.left.item)

            if pop_node.right is not None:
                q.append(pop_node.right)
                res.append(pop_node.right.item)
        return res

    def preorder(self, root):  # 先序遍历
        if root is None:
            return []
        result = [root.item]
        left_item = self.preorder(root.left)  #递归调用
        right_item = self.preorder(root.right)
        return result + left_item + right_item #根结点 左子树结点 右子树结点

    def inorder(self, root):  # 中序序遍历
        if root is None:
            return []
        result = [root.item]
        left_item = self.inorder(root.left)
        right_item = self.inorder(root.right)
        return left_item + result + right_item #左 根 右

    def postorder(self, root):  # 后序遍历
        if root is None:
            return []
        result = [root.item]
        left_item = self.postorder(root.left)
        right_item = self.postorder(root.right)
        return left_item + right_item + result #左 右 根
    
if __name__ == '__main__':
    t = Tree()
    for i in range(10): #10个结点
        t.add(i)
    print('层序遍历:', t.traverse())
    print('先序遍历:', t.preorder(t.root))
    print('中序遍历:', t.inorder(t.root))
    print('后序遍历:', t.postorder(t.root))

推导遍历结果：
在这里插入图片描述

孤岛使者
关注
专栏目录
二叉树（理论篇）
刘森林l的博客
08-01 1114
 二叉树：          二叉树是每个节点最多有两个子树的树结构 1.二叉树的每个结点至多只有二棵子树(不存在度大于2的结点)， 2.二叉树的子树有左右之分，次序不能颠倒。 3.二叉树的第i层至多有2^（i-1）个结点；深度为k的二叉树至多有2^k-1个结点； 4.对任何一棵二叉树T，如果其终端结点数为n_0，度为2的结点数为n_2，则n_0=n_2+1。 满二叉
二叉树
01-04
希望对大家有用 随机建立二叉树 在进行根节点的查找 二叉树
【数据结构】二叉树
最新发布
DerrictC的博客
09-18 1181
该算法从堆的根节点开始，通过比较和交换节点值，将根节点调整到其在堆中的正确位置，以确保堆的每个父节点的值都大于或等于其子节点的值（在最大堆中），或者小于或等于其子节点的值（在最小堆中）。我们常见的二叉树的结构叫逻辑结构如下图1，这是我们自己想象出来的二叉树的样子，但实际上二叉树并不是就像图中所示的那样，二叉树真正的结构，也叫物理结构，是像数组一样每个数据一行排开，如图2，图2所示及是实实在在。也就是说，如果一个二叉树的层数为K，且结点总数是(2^k) -1 ，则它就是满二叉树。如果二叉树为空，则退出；
二叉树(理论篇)
二进制君
08-04 1081
   一、什么是树？         在前几篇的博文中主要讲述的是链式存储这种数据结构，它们的用途非常广泛，但是在实际的应用中，还存在着另一种非常重要的数据结构，它就是树。树的结构示意图如下所示：         上图就是一种数据结构----树，之所以在每个框中都留出空白，主要原因是这种结构如果根据上下文是能够传达一些重要的结构信息，比如我们可以作如下思考：         1、上图可以...
二叉树理论
qq_42138662的博客
06-18 205
一、满二叉树与完全二叉树 在我们解题过程中二叉树有两种主要的形式：满二叉树和完全二叉树。 二、二叉搜索数与平衡二叉搜索树 1、二叉搜索树 二叉搜索树是一种节点值之间具有一定数量级次序的二叉树，对于树中每个节点： 若其左子树存在，则其左子树中每个节点的值都不大于该节点值； 若其右子树存在，则其右子树中每个节点的值都不小于该节点值。 2、平衡二叉搜索树(AVL树) AVL树满足以下要求： 左子树与右子树高度之差的绝对值不超过1 树的每个左子树和右子树都是AVL树 每一个节点都有一个平衡因子（balan
二叉树基本理论
qq_51088445的博客
10-28 321
二叉树是我们经常会用到的一种数据结构，在我们日常刷题和编程中都有很大的用处，本篇讲一下我所了解的二叉树的相关知识。 满二叉树 满二叉树： 一个二叉树只有度为0和度为2的结点，且度为0的结点都在同一条线上，这种二叉树就叫做满二叉树。 图例： ...
算法-理论基础- 二叉树- 二叉树的遍历（包含源程序）.rar
09-16
通过阅读《算法-理论基础- 二叉树- 二叉树的遍历（包含源程序）.pdf》这份文档，你将能够深入理解二叉树遍历的概念，并有机会通过实际的源代码加深理解，从而更好地掌握这个重要的数据结构和算法知识。在学习过程中...
算法-理论基础- 二叉树（包含源程序）.rar
09-16
这个压缩包文件“算法-理论基础- 二叉树（包含源程序）.rar”显然提供了关于二叉树理论基础的详细讲解以及相关的源代码实现，非常适合学习者深入理解二叉树的原理和应用。 首先，我们来详细探讨二叉树的基本概念。...
算法-理论基础- 二叉树- 二叉链表（包含源程序）.rar
09-16
熟悉二叉树理论基础和实践技巧是成为优秀程序员的重要一步。 在这个压缩包中，"算法-理论基础- 二叉树- 二叉链表（包含源程序）.pdf"文件很可能是详细的教程或课件，它可能涵盖了二叉树的定义、性质、遍历方法、...
算法-理论基础- 二叉树- 三叉链表（包含源程序）.rar
09-16
源代码文件“算法-理论基础- 二叉树- 三叉链表（包含源程序）.pdf”很可能包含了具体的实现细节和示例，涵盖了如何创建、遍历以及在二叉树和三叉链表上执行操作的方法。通过阅读这些源码，你可以了解如何用编程语言...
算法-理论基础- 二叉树- 线索链表（包含源程序）.rar
09-16
二叉树是计算机科学中一种重要的数据结构，它在算法设计和实现中...提供的PDF文档"算法-理论基础- 二叉树- 线索链表（包含源程序）"应该会详细介绍这个主题，包括理论概念和具体的源代码实现，建议仔细阅读以加深理解。
【数据结构】二叉树——理论篇
Shun_Hua的博客
03-26 1722
二叉树的相关概念
二叉树理论基础
眼映星辰的博客
10-11 766
1. 二叉树的定义 二叉树是每个节点最多有两个子树的树结构。它有五种基本形态：二叉树可以是空集；根可以有空的左子树或右子树；或者左、右子树皆为空。   2. 二叉树的性质 二叉树有以下几个性质：TODO(上标和下标)性质1：二叉树第i层上的结点数目最多为 2{i-1} (i≥1)。性质2：深度为k的二叉树至多有2{k}-1个结点(k≥1)。性质3：包含n个结点的二叉树的高度至少为log...
七、二叉树（1）：二叉树理论基础
努力努力努力
09-10 261
说道二叉树，大家对于二叉树其实都很熟悉了，本文呢我也不想教科书式的把二叉树的基础内容在啰嗦一遍，所以一下我讲的都是一些比较重点的内容。相信只要耐心看完，都会有所收获。 一、二叉树的种类 在我们解题过程中二叉树有两种主要的形式：满二叉树和完全二叉树。 1.1 满二叉树 满二叉树：如果一棵二叉树只有度为0的结点和度为2的结点，并且度为0的结点在同一层上，则这棵二叉树为满二叉树。 如图所示： 这棵二叉树为满二叉树，也可以说深度为k，有2^k-1个节点的二叉树。 1.2完全二叉树 什么是..
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值