数据结构（三）树与二叉树基本概念

最新推荐文章于 2023-04-08 21:41:50 发布
最新推荐文章于 2023-04-08 21:41:50 发布
阅读量2.1k 收藏 8
点赞数 2
分类专栏： 考研复习数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43633784/article/details/108639198
版权

一、树的基本概念

1. 树的定义

树是N个结点的有限集合，N=0，为空树。树是一种逻辑结构，同时也是一种分层结构。树的定义是递归的：

  1. 有且仅有一个根节点
  2. 当N>1时，其余结点可分为m个互不相交的子集，每一个子集又是一棵树，称为根节点的子树

每个结点只有一个前驱但是可以有0个或多个后继
树适合表示具有层次关系的数据结构。

2. 基本术语

  1. 祖先结点/子孙结点/孩子结点/兄弟结点
  2. 结点的度：树中一个结点的子节点个数，树中结点最大的度称为树的度
  3. 分支结点（非终端结点）：度大于0的结点；叶节点（终端节点）：度为0
  4. 结点的层次/结点的高度/结点的深度/树的高度（最大层数）
  5. 有序数/无序树：树中结点的子树从左到右是有序的
  6. 路径/路径长度：两个结点之间所经过的结点序列/路径上经过的边数（同一双亲结点的孩子结点之间不存在路径）
  7. 森林：m棵不相交的子树的集合

3. 树的性质

  1. 树中结点数等于所有节点的度数+1
  2. 度为m的树中第i层上至多有mi-1个节点
  3. 高度为h的m叉树至多有（mh-1)/(m-1)个结点（求和公式）
  4. 具有n个结点的m叉树的最小高度为[logm(n(m-1）+1）]
补充:
  1. 树的路径长度是所有路径长度的总和
  2. 总结点数=N0+N1+…+Nn
  3. 总分支数=1xN1+2xN2+…+nxNn
  4. 总结点数=总分支数+1

二、二叉树

  1. 二叉树与度为2的树的区别
    （1)度为2的树至少有3个结点，而二叉树可以为空
    （2)度为2的树的孩子结点的所有次序是相对于另一个孩子结点来说的，如果只有一个孩子结点就不分次序；如果是二叉树，结点的次序不是相对于另一个节点而言的而是其自己本身就具有顺序性
  2. 几个特殊的二叉树
    （1)满二叉树
    如果对二叉树按层次编号，则有对于编号为i的结点，如果有双亲，则双亲为i/2(取地板），左孩子为2i，右孩子为2i+1【前提是在他们都存在的情况下】
    （2)完全二叉树
    按照满二叉树的编号方式能够一一对应上
  • 当i<=n/2( 取地板）的时候，都是分支结点，否则为叶子结点
  • 叶子结点只能出现在层次最大的两层上，对于最大层次中的叶子结点，都依次在该层的最左边的位置上
  • 如果有度为1的结点，只能有1个，且该结点只有左孩子没有右孩子
  • 按照层序编号后，一旦出现某结点为叶子结点或者只有一个左孩子，则该节点后面的结点全都是叶子结点
  • 如果n为奇数，则每个分支结点都有左孩子和右孩子，如果为偶数，则编号最大的分支结点只有左孩子
    （3)二叉排序树
    左子树的关键字都小于根，右子树都大于根。
    （4)平衡二叉树
    树上任一结点的左子树和右子树的深度差不超过1
  1. 二叉树的性质
    （1)叶子结点个数等于度为2的节点个数+1
    （2）高度为H的二叉树至多有2H-1
    （3)含有N个结点的完全二叉树的高度是log2(N+1）【取天棚】
  2. 二叉树的存储结构
    （1)顺序存储结构
    树的顺序存储只是代表从上到下从左到右的关系，但是二叉树的顺序存储不仅是单纯的存储数据，还表示了结点之间的关系。
    （2）链接存储结构
    一般二叉树都采用链接存储结构，适用一个链表来存储一棵二叉树，至少包括3个域：数据域data，左指针域lchild，右指针域rchild，根据不同的需要增加不同的指针域。
typedef struct BiTNode{
 Elemtype data;
 struct BiTNode *lchild,*rchild;
}BiTNode,*BiTree;

n个结点的二叉链表中含有n+1个空指针域

二叉树的遍历

1. 先序遍历/中序/后序（就是改变visit的位置）
void PreOrder(BiTree T){
   if(T!=NULL)
   {
   visit(T);
   PreOrder(T->lchild);
   PreOrder(T->rchild);
   }
}

在递归遍历中，递归工作栈的栈深恰好为树的深度，所以在最坏的情况下，二叉树是有n个结点且深度为n的单支树，时间复杂度是O(n)
非递归形式：

//中序遍历
/*
将根节点及其左子树全部入栈操作，但不进行访问，当结点为空，停止入栈；
访问栈顶元素作为当前结点并出栈，如果当前结点有右子树则遍历访问其右子树
栈顶元素上一个元素就是当前元素的父节点
*/
void InOrder2(BiTree T){
InitStack(S);
BiTree p = T;
while(p||!IsEmpty(s))
{
   if(p){
   Push(S,p);
   p=p->lchild;
   }
   else{
   Pop(S,p);
   visit(p->data);
   p=p->rchild;
   }
 }
}
//先序遍历
/*
当栈不为空或当前结点不为空时，执行操作；
取栈顶元素为当前结点，并出栈，如果当前结点有右子树，遍历其右子树
*/
void PreOrder2(BiTree T)
{
    BiTree p=T;
    while(p||IsEmpty(s))
    {
      if(p){
      visit(p->data);
      Push(S,p);
      p=p->lchild;
      }
      else{
      Pop(S,p);
      p=p->rchild;
}    
}
}

//后序遍历
/*后序遍历和前面的有所区别，要后序遍历需要节点访问两遍，所以需要一个专门的count部分记录当前节点被访问的次数*/
typedef struct NewNode{
    BiTree t;
    int count;
}Node,*pNode;
void PostOrder2(BiTree t){
 if(T == nullptr)
    return nullptr;
 Node p;
 p.count = 0;
 p.t = t;
 InitStack(S);
 Push(S,p);
 while(!IsEmpty(S)){
 Node q;
 Pop(S,q);
 if(q.count == 0)
    {
    q.count ++;
    Push(S,q);
   if(q.t.lchild != nullptr)
  {
   q.t = q.t.lchild;
   Push(S,q);
  }//开始第一次一定是先访问左节点此时count=0，在第一次进入的时候判断是否有左节点可以进入
}
else if (q.count ==1 )//当count是1的时候，已经访问一次了该访问右节点了
{
    q.count ++;
    Push(S,q);
    if(q.t.rchild!=nullptr)
    {  q.t = q.t.rchild;
       Push(S,q);
      }
}
else if(q.count == 2)//计数两次可以访问了
{
visit(q.t.data);
}
}

}
2. 层次遍历

思路：使用层次遍历需要一个队列，首先将根节点入队，然后判断当前根节点是否有左右子树，如果有左右子树则按左右的顺序进入，按照正常的出队的顺序弹出

void LevelOrder(BiTree t){
   InitQueue(Q)
   BiTree p;
   EnQueue(Q,p);
   //不用再设置一个变量更新p没有用
   while(!IsEmpty(Q)){
   DeQueue(Q,p);
   visit(p->data);
   if(p->lchild!=nullptr)
    {
      //temp =temp-> lchild;
      EnQueue(Q,p->lchild);
}
   if(p->rchild!=nullptr)
     {
     //temp = temp -> rchild;
     EnQueue(Q,p->rchild);
     }  
}
}

对于一棵已知树求节点的双亲、求结点的孩子结点、求二叉树的深度、求二叉树的叶子节点个数、判断两棵二叉树是否相同

3. 由遍历序列构造二叉树
  1. 二叉树的先根序列和‘#’（随便指定一个分界符）表示空指针，可以创建一棵二叉树
    可以利用一个栈来操作
  2. 二叉树的先序序列和中序序列可以唯一构建一棵二叉树
    根据先序序列确定当前要判断的一组节点的根节点，然后去中序序列中找到这个节点，将所有元素划分成两个部分，左侧的属于左子树，右侧属于右子树（很明显就递归）
  3. 二叉树的后序序列和中序序列可以唯一构建一棵二叉树
    和上面同理，不过后序序列从最后一个往前遍历，先右后左，然后和上面的方法相同
  4. 二叉树的层次序列和中序序列可以唯一构建一棵二叉树
4. 线索二叉树
  1. 二叉树的各种遍历实际上是非线性结构的线性化操作，使在访问中的每一个节点都有一个直接前驱和直接后继。
  2. 利用空指针存储各种遍历的前驱和后继指针，加快查找前驱和后继节点的速度。
  3. 线索二叉树的存储结构：
/*
结构说明；
data：数据域
lchild：ltag=1指向结点的前驱；ltag=0指向结点的左子树
rchild：rtag=1指向结点的后继；rtag=0指向结点的右子树
*/
typedef struct ThreadNode{
   ElemType data;
   struct ThreadNode *lchild,*rchild;
   int ltag,rtag;
}ThreadNode,*ThreadTree;

由这种结点结构构成的二叉链表作为二叉树的存储结构，叫做线索链表；指向结点前驱和后继的指针叫做线索；加上线索的二叉树叫做线索二叉树；对线索二叉树的某种次序的遍历过程叫线索化

  1. 线索二叉树的构造
    实际上只是遍历一次二叉树，只是在遍历过程中，检查当前结点左右指针是否为空，若为空，则将它们改为指向前驱结点或后继结点的线索。最后还要处理一下最后一个结点。
void InThread(ThreadTree &p,ThreadTree &pre){
if(p!=nullptr){
 InThread(p->lchild,pre);
 if(p->lchild==nullptr){
  p->lchild = pre;
  p->ltag = 1;
}
 if(pre->rchild==nullptr&&pre!=nullptr)
 {
 pre->rchild = p;
 pre->rtag = 1;
}
pre = p;
InThread(p->rchild,pre);

}
}
void CreateInThread(ThreadTree T){
  ThreadTree pre = nullptr;
  if(T!=nullptr){
    InThread(T,pre);
    pre->rchild = nullptr;
    pre->rtag=1;
}
}

也会在二叉树的线索链表上添加一个头节点，其lchild域的指针指向二叉树的根节点，其rchild域的指针指向中序遍历是访问的最后一个节点。反之，第一个结点的lchild域和最后一个节点的rchild域均指向头节点。（建立一个双向线索链表，可以从第一个节点起后继遍历，也可以从最后一个结点起顺前驱遍历）

  1. 线索二叉树的遍历
/*
可以利用线索二叉树实现二叉树遍历的非递归算法
a/如果rtag=1 则rchild指向中序后继
b/如果rtag=0 则中序后继应该是以当前节点为根的子树的中根序列的首节点
*/

ThreadNode *Firstnode(ThreadNode *p){
  while(p->ltag==0)
    p=p->lchild;
  return p;
}
ThreadNode *Nextnode(ThreadNode *p){
  if(p->rtag == 1) return p->rchild;
  return Firstnode(p->rchild);
}
//主函数
void Inorder(ThreadNode *T){
for(ThreadNode *p=Firstnode(T);p!=nullptr;p=Nextnode(T))
    visit(p);
}

三、树、森林

1. 树的存储结构

树的存储方式有很多种，既可以采用链式存储也可采用顺序存储，关键在于能够唯一的反映出树中各结点之间的逻辑关系。常用三种表示方法如下：

  1. 双亲表示法
    采用一组连续的存储空间来存储每个结点，同时在每个结点中增设一个伪指针，指示其双亲结点在数组中的位置。根节点的下标为0，其伪指针域为-1。该结构可以很快的得到每个结点的位置，但是求结点的孩子结点就需要遍历整个结构。
# define MaxSize 100
//树的结点定义
typedef struct{
    ElemType data;
    int parent;
}PTNode;
//树的类型定义
typedef struct {
  PTNode nodes[MaxSize];//双亲表示
  int n;//结点数
}PTree;
  1. 孩子表示法
    将每个结点的孩子结点都用单链表链接起来形成一个线性结构，N个结点就有N个孩子链表。叶子节点的孩子链表是空表。在寻找当前节点的双亲节点的时候需要遍历整个结构。
    在这里插入图片描述
  2. 孩子兄弟表示法
    以二叉链表作为树的存储结构。孩子兄弟表示法是使每个结点包含三部分内容：结点值、指向结点第一个孩子结点的指针和指向结点下一个兄弟结点的指针（沿此域可以找到所有的兄弟结点）
typedef struct CSNode{
   ElemType data;
   struct CSNode *firstchild,*nextsibling;
}CSNode,*CSTree;

缺点：查找双亲结点比较麻烦，如果为每个结点增设一个parent域指向其父节点，则查找父节点也很方便。

2.树、森林与二叉树的转换

树和二叉树都可以用二叉链表表示，可以由二叉链表导出二者的对应关系：给定一棵树🈶️唯一一棵二叉树与之对应。

从物理结构上说，树的孩子兄弟表示法与二叉树的二叉链表表示法相同.可以用同一种结构的不同解释将一棵树转化为二叉树。

  • 树转换成二叉树的规则：
    每个结点的左指针指向它的第一个孩子结点，右指针指向它在树中的相邻兄弟结点，由于根节点没有兄弟，所以，由树转换成的二叉树没有右子树。
    在这里插入图片描述
  • 森林转换成二叉树的规则：
    先将森林中的每棵树都转换成二叉树，然后将第一个二叉树的根节点作为转化后的二叉树的根节点，第一棵树的左子树作为转换后二叉树根的左子树，第二棵树作为转换后的右子树，第三棵树作为转化后的二叉树的根的右子树。
    （利用了树转换成的二叉树没有右子树）
  • 二叉树转换成森林的规则：
    如果二叉树非空，则二叉树根及其左子树为第一棵树的二叉树形式。二叉树根的柚子树又可以看作是一个由除第一棵树外的森林转换成的二叉树，直到最后产生一棵没有右子树的二叉树为止。

3. 树和森林的遍历

没有中序遍历，一个节点有多个子树，没有办法看哪个是中间的。

树的遍历
（1）先根遍历

如果树非空，则先访问根结点，再按从左到右的顺序遍历根结点的每一棵子树，其访问顺序与这棵树的对应的二叉树的先序遍历顺序相同。

（2）后根遍历

若树非空，则按从左到右的顺序遍历根节点的每一棵子树，之后再访问根结点的每一棵子树，之后再访问跟节点，其访问顺序和这棵树对应的二叉树的中序遍历顺序相同。

在这里插入图片描述

（3）层次遍历

层次遍历与二叉树的层次遍历思想基本相同，即按层序依次访问各结点。

森林的遍历
（1）先序遍历森林
  1. 访问森林中的第一棵树的根结点
  2. 先序遍历第一棵树的根结点的子树森林
  3. 先序遍历除去第一棵树之后剩余的树构成的森林
（2）中序遍历森林
  1. 中序遍历森林中的第一棵树的根结点的子树森林
  2. 访问第一棵树的根结点
  3. 中序遍历除去第一棵树之后剩余的树构成的森林
树和森林的遍历和二叉树遍历的关系
树森林二叉树
先根遍历先序遍历先序遍历
后根遍历中序遍历中序遍历

树的顺序表示：

  1. 先根序列和结点次数
  2. 后根序列和结点次数

4. 树的应用——并查集

并查集是一种简单的集合表示，支持三种操作：

  1. Union(S,Root1,Root2):把集合S中子集合Root2并入子集合Root1中。要求Root1和Root2互不相交，否则不执行合并
  2. Find(S,x):查找集合S中单元素x所在的子集合并返回该子集合的名字
  3. Initial(S):将集合S中的每一个元素都初始化为只有一个元素的集合

使用双亲表示作为并查集的存储结构，每个子集合以一棵树表示，所有表示子集合的树，构成表示全集合的森林，存放在双亲表示数组内，通常用数组元素的下标表示元素名，根结点的下标代表子集合名，根结点的双亲结点为负数。
两个子集合合并，只需将其中一个子集合的根结点的双亲指针指向另一个集合的根结点即可

#define SIZE 100
int UFSets[SIZE];
//并查集的初始化操作
void Initial(int S[]){
for (int i=0;i<size;i++){
     S[i]=-1;
}
}
//Find操作
int Find(int S[],int x){
     while(S[x]>=0)
        x = S[x];
     return x;
}
//Union操作
void Union(int S[],int Root1,int Root2){
     //要求Root1和Root2是不同的，且表示子集合的名字
     S[Root2]=Root1;
}

四、树与二叉树的应用

（一）二叉排序树（BST树）/二叉查找树

. 定义：

  1. 若左子树非空，则左子树上所有结点的关键字值均小于根结点的关键字值
  2. 若右子树非空，则右子树上所有结点的关键字值均大于根结点的关键字值
  3. 左右子树本身也分别是一棵二叉排序树

对二叉排序树进行中序遍历可以得到一个递增的有序序列

1. 二叉排序树的查找

思路：
从根结点开始，沿某一个分支逐层向下进行比较。如果二叉排序树非空，将给定值与根节点的关键字比较，若相等则查找成功；若不等，如果根节点大于给定关键字值，在根结点的左子树中查找；如果根结点小于给定关键字值，在根结点的右子树中寻找。

/*
函数功能：查找函数返回指向关键字值为key的结点指针，若不存在，则返回null
p:指向被查找结点的双亲，用于插入和删除操作中
*/
BSTNode *BST_Search(BiTree T,ElemType key,BSTNode *&p){
p=nullptr;
while(T!=nullptr&&key!=T->data){
  p=T;
  if(key<T->data) T = T->lchild;
  else T = T->rchild;
}
return T;
}
2. 二叉排序树的插入

二叉排序树作为一种动态集合，其特点是树的构造不是一次生成的，而是在查找过程中不存在关键字等于给定值的结点时再进行插入。插入的新节点一定是某个叶节点。

int BST_Insert(BiTree &T,KeyType k){
if(T == nullptr)
{
   T = (BiTree)malloc(sizeof(BSTNode);
   T->key = k;
   T->lchild = T->rchild = nullptr;
   return 1;
}
else if(k == T->key)
    return 0;
else if(k < T->key)
   BST_Insert(T->lchild,k);
else{
   BST_Insert(T->rchild,k);
 }
}
3. 二叉排序树的构造

二叉树的构造实际上就是从输入的第一个元素开始构建排序二叉树。所以只需要一个循环调用二叉树插入部分即可。

void Creat_BST(BiTree &T,KeyType str[],int n){
    T = nullptr;
    int i = 0;
    while(i<n){
     BST_Insert(T,str[i]);
     i++;
}
}
4. 二叉排序树的删除

思路：把删除结点从存储二叉排序树的链表中取下来，将因删除而断开的链表重新连接，但是要保留二叉排序树本来的性质。
如果是删除考虑以下三种情况：（二叉树中结点也就这三种位置情况）

  1. 如果被删结点是叶节点——直接删除
  2. 如果被删结点只有一棵左子树或者右子树——使用左子树或者右子树直接代替被删结点的位置
  3. 如果被删结点有左右两棵子树——（想办法转换为前两种情况）将被删结点的中序排列序列的第一个复制到被删除结点的位置上，然后删除这个中序排列的第一个元素，如果仍然是有左右两棵子树继续重复这个操作，直到到情况1和情况2，而且也一定能到情况1 和情况2

在这里插入图片描述
思考：若在二叉排序树中删除并插入某结点，得到的二叉排序树是否和原来的相同？
如果删除的结点是叶结点的话，得到的二叉树和原来的相同；
如果不是叶节点的话，由于插入节点一定是插入在二叉树的叶节点部分，而删除的时候结点是二叉树的非叶节点，所以二者一定不同。

5. 二叉排序树查找效率分析

  • 二叉排序树的高度为H，则复杂度为O(H)
    如果二叉树退化（输入有序序列形成单链表），复杂度为O(n)

  • 从查找过程上看，二叉排序树与二分查找相似；就平均时间性能来看，二叉排序树上的查找和二分查找差不多。但二分查找的判定树唯一，二叉排序树不唯一。相同的关键字插入顺序不同，得到的二叉树不同。

什么时候用二叉排序树？什么时候用二分查找？

【二叉排序树的构造是为了查找比较，所以和二分查找的最终目的是一样的，但是二叉排序树在插入和删除结点只需要更改指针的指向。插入和修改时，二叉排序树O(logN),二分查找O(N)】

当有序表是静态查找表时，使用顺序表作为存储结构，采用二分查找实现查找操作；
当有序表时动态查找表时，使用二叉排序树作为逻辑结构。

（二）二叉平衡树（AVL树）

在插入和删除时保证任意结点的左右子树的高度差的绝对值不超过1，这样的二叉树称为二叉平衡树。
平衡因子：结点左子树和右子树的高度差（-1，1，0）
（一般用左节点-右节点）

1. 二叉平衡树的插入

思路：首先要检查其插入路径上的结点是否因为这次操作导致了不平衡，如果导致不平衡，首先应该找到插入路径上离插入节点最近的平衡因子绝对值大于1的结点A，再对以A为根的子树，在保持二叉排序树特性的前提下，调整各结点之间的位置关系，使其重新达到平衡。（从下往上一点点调整）

每次调整的都是最小不平衡子树——在插入路径上离插入节点最近的平衡因子的绝对值大于1 的结点作为根的子树。

根据失去平衡后进行调整的规律归纳为以下4种情况：
LL、RR、RL、LR
在这里插入图片描述
左孩子的左子树插入新结点：
(1)A结点向下旋转变成B结点的右子树
(2)B结点代替A变成根结点
(3)原B结点的右子树变成A结点的左子树

在这里插入图片描述
右孩子的右子树插入新结点：
左边变化同上方法。

在这里插入图片描述
右孩子的左子树插入新结点：
先将A结点的右孩子B的左子树的根结点C向右上旋转到（右上旋转包括根结点的替换和替换上去的结点的有一个子树被拆下换到原来根结点的子树部分）B结点位置，然后再将C结点旋转到左上替换到A结点的位置。
在这里插入图片描述
左孩子的右子树插入新结点：
同上。

2. 二叉平衡树的查找
  • 含有n个结点的平衡二叉树的最大深度为O(logN)，也是平衡二叉树的平均查找长度
  • Nh表示深度为h的平衡树中含有的最少结点数，N0=0,N1=1,N2=2,并且有Nh=Nh-1+Nh-2+1
  • 求解给定结点数的平衡二叉树的查找所需的最多比较次数（或树的最大高度）——给结点数直接用其去求当这些作为最少的时候最深的高度是多少。

（三）哈夫曼树和哈夫曼编码

1. 相关定义

内通路长度：从根到每个内节点的路径长度之和
外通路长度：从根到每个外结点的路径长度之和
带权路径长度：从树的根结点到任意结点的路径长度（经过的边数）与该结点上权值的乘积
树的带权长度：树中所有带权路径长度之和

WPL = 0;
for( int i=1;i<=n;i++)
   WPL = WPL+wi*Li;

最优二叉树/哈夫曼树：WPL最小的二叉树
扩充二叉树：每当二叉树中出现空子树时，就增加特殊的结点——空树叶，由此生成的二叉树。

2. 哈夫曼树的构造

哈夫曼算法：

  1. 将这N个结点分别作为N棵含一个结点的二叉树，构成森林F
  2. 构造一个新节点，并从中选取两棵根结点权值最小的树作为新结点的左右子树，并且将新节点的权值置为左右子树上根结点的权值之和
  3. 从F中删除刚才选择的两棵子树，同时将新得到的树加入F中
  4. 重复2、3，直至F中只剩下一棵树为止
3. 哈夫曼编码
  1. 固定长度编码：每个字符用同样长度的二进制位来表示
  2. 可变长度编码：不同字符使用不等长的二进制位来表示
  3. 数据压缩编码
  4. 前缀编码：没有一个编码是另一个编码的前缀

哈夫曼编码：将每个出现的字符作为一个独立的结点，其权值为它出现的频度，构造出对应的哈夫曼树。将字符的边编码解释为从根到该字符的路径上边标记的序列，其中边标记为0表示“转向左孩子”，标记为1表示“转向右孩子”

⚠️每个结点的权值都是其所有直接子节点之和
⚠️构造的哈夫曼树不唯一，但是各哈夫曼树的带权路径相同且为最优

pudding_art
关注
  • 2
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
让二叉树更好——三叉树和线索二叉树（遍历的简化）
筱羊冰冰
08-03 2124
你是否已经厌倦了，那只能找到孩子却不能反向寻找双亲结点，那遍历起来想要砸键盘的、陈旧的二叉树？今天，就是我们站起来了的时候了。（雾） 好了不皮了，先看一下定义 三叉树 这个名字不是指度最大为三的树，而是在二叉树（两个指针）的基础上多了个指针，因为二叉树找双亲结点只能用栈存储然后回溯，或者只能一个个结点的寻找，非常麻烦的。 （别问名字为什么这样，问就是学校ppt教的，不过也很形象） 好处： 首先就是找到从根节点到任意节点的路径方便了很多； 另外是在非递归遍历的时候，之前的二叉树结构想要回溯就只能借助栈，而现在
数据结构 | 3.树与二叉树
明朗晨光的专栏
09-14 1823
在 栈和队列 一文中提到，栈可以处理具有 完全包含 关系的问题。 而树分为两部分：结点 和 边。结点可以理解为集合，边称为关系。树的根结点就叫做全集，子节点叫做子集，子集并起来就得到了全集。 根结点就是待解决的问题，可能是个大问题，可以划分为多个子问题，即是子结点。 树也存在着一种完全包含关系。树和栈是有一定关联的，遍历树的时候就要使用栈，而且使用到的是系统栈，用到系统栈的表现形式就是递归。 1、树的深度、高度和度 树的根结点所在层数为第一层。结点下有几个子结点，度就为几。 深度 是从根往下的层数，高度
【常用数据结构——二叉树（还有三叉四叉...？ ）】
weixin_30394633的博客
08-13 1586
---恢复内容开始--- 简介 　　在计算机科学中，二叉树是每个结点最多有两个子树的有序树。通常子树的根被称作“左子树”（left subtree）和“右子树”（right subtree）。二叉树常被用作二叉查找树和二叉堆或是二叉排序树。 基本术语　 子树：除了根节点外，每个子节点都可以分为多个不相交的子树。 孩子与双亲：若一个结点有子树，那么该结点称为子树根的"双亲"，...
H.266/VVC中的四叉树+三叉树+二叉树(更新)
小小柴的博客
07-26 5473
        H.266已经确定采用混合树结构（MT），即由四叉树（QT），二叉树（BT）和三叉树（TT）结构组成。这种划分结构比之前非常灵活，极大的提高了编码性能。        CTU首先由四叉树结构划分，即CTU块可以不划分或递归地划分成4个相同大小的子块。然后，在QT的叶节点可以通过二叉树或三叉树结构进一步划分。二叉树和三叉树划分可以交错并递归进行。但是，一旦应用二叉树或三叉树划分，就...
求解：树的叶子结点的相关问题？
demo_yo的博客
04-13 2536
已知一棵度为3的树有2个度为1的结点,3个度为2的结点,4个度3的结点,则该树有几个叶子结点? 设该树中的叶子数为n0个.该树中的总结点数为n个,则有： n=n0+n1+n2+…+nm (1) 又有除根结点外,树中其他结点都有双亲结点,且是唯一的(由树中的分支表示),所以,有双亲的结点数为： n-1=0n0+1n1+2n2+…+mnm (2) 联立(1)(2)方程组可得： 叶子数为：n0=1+0n...
数据结构与算法：树和二叉树.pptx
05-11
数据结构中的树是一种重要的非线性数据结构，它模拟...总的来说，理解和掌握树和二叉树的概念、术语、性质及其应用是学习数据结构与算法的重要基础，它们在软件开发、数据库设计、编译原理等多个领域都有着广泛的应用。
数据结构与算法树与二叉树
01-31
数据结构与算法树与二叉树 树是一种非线性数据结构，常用于存储和管理大量数据。它由节点和边组成，每个节点都包含一个值和一个或多个子节点的指针。树的基本信息包括定义、基本术语、森林与树的关系、树结构与线性...
实验三 树和二叉树.rar
03-01
本实验旨在帮助初学者深入理解树与二叉树的基本概念，通过编写代码来实现相关操作，提升实际编程能力。 首先，我们来了解一下树的基础知识。树是一种非线性的数据结构，它由若干个节点（或称为顶点）和连接这些节点...
头歌数据结构二叉树的顺序存储及基本操作
05-18
在计算机科学中，二叉树是一种重要的数据结构，它的每个节点最多有两个子节点，分别称为左子树和右子树。这种特殊的树形结构在很多领域都有应用，特别是在文件系统和数据库系统中，利用二叉树可以实现高效的排序和...
广工数据结构实验——平衡二叉树
07-06
在这个实验中，`平衡二叉树数据结构实验.cpp`很可能是实现平衡二叉树（可能是AVL树或红黑树）的C++源代码。它可能包含了基本的二叉树操作（如插入、删除和查找）以及平衡调整算法的实现。源代码可以帮助我们理解如何...
【数据结构】树与二叉树的基本概念及性质
最新发布
仔仔木的博客
04-08 1006
数据结构中的树是什么❓树是个结点的有限集。有且仅有一个特定的称为根(上图A结点)的结点。当 n>1 时，其余结点可分为 m(m>0) 个不相交的有限集，其中每个集合本身又是一棵树，并且称为根的子树。💡空树：n=0树有哪些特点❓树的根结点没有前驱,除根结点外的所有结点有且只有一个前驱。树中所有结点都可以有零个或多个后继。
数据结构（树与二叉树）
jxttutu的博客
03-12 4433
5.1.1树和二叉树的定义 树：是n(n>=0)个结点的有限集，或为空树(n==0),或为非空树 非空树满足：1.有且仅有一个称之为根的结点 2.除根节点之外的其余结点可分为m(m>0)个互不相交的有限集，其中每个集合本身又是一棵树，并且称为根的子树。（递归定义） 5.1.2树的基本术语： 1.结点：树中的一个独立单元，包含一个数据元素和若干个指向子树的分支 2.根结点：非空树中无前趋的结点 ...
浅谈数据结构与算法（四）
攻城狮的成长历程
03-28 1358
数据结构与算法（四）树顺序存储结构链式存储结构二叉树的遍历 树 树是n(n>=0)个结点的有限集 它可以是一颗空树(n=0)，空树不包括任何结点 或者是一颗非空树(n>0)，此时有且只有一个特定的称为根的结点，当n>1时，其余结点可分为m个互不相交的有限集，其中每一个本身又是一棵树，称为根的子树(sub tree) 结点的度与树的度 结点拥有的子树的个数称为结点的度 度为...
java如何定义三叉树_原创：自定义三叉树（二）--基于搜索推荐系统根据用户搜索频率（热搜）排序...
weixin_29189381的博客
02-25 566
之前写的三叉树，有点儿简单，并不能满足实际项目的需要。先简单分析一下solr中搜索推荐系统的核心算法。wiki中有关于solr的搜索推荐的详细描述，但是核心算法需要自己查看源代码。关于wiki上的解读，之前做了一次简单的翻译，根据此文档，详细研读了源代码，先把核心思想呈现出来。基本流程如下：当用户输入搜索词语前缀时，通过前端调用solr的suggest，找到Suggeser对象，Suggester...
Java基础 （三）：LinkedList（含使用方法详解）
热门推荐
Viper的程序员修炼手册
07-20 1万+
Java LinkedList 链表（Linked list）是一种常见的基础数据结构，是一种线性表，但是并不会按线性的顺序存储数据，而是在每一个节点里存到下一个节点的地址。 链表可分为单向链表和双向链表。 一个单向链表包含两个值: 当前节点的值和一个指向下一个节点的链接。 一个双向链表有三个整数值: 数值、向后的节点链接、向前的节点链接。 Java LinkedList（链表） 类似于 ArrayList，是一种常用的数据容器。 与 ArrayList 相比，LinkedList 的增加和删除对操作效
树的三叉链的创建和遍历
一叶知秋
01-18 3731
树的三叉链的创建和遍历，和二叉树的不同就是结点定义多了parent，和创建函数中的部分代码不一样图示如下代码如下：#include #include #include #define DataType char #define MAXSIZE 100 using namespace std; typedef struct Node{ DataType data; struct Node *l
94. 二叉树的中序遍历
lankerens
09-14 115
LeetCode： 94. 二叉树的中序遍历 迭代写法： 使用栈 遍历到最后的左子树，然后输出，再处理右子树 public class Daily94 { List<Integer> res = new ArrayList<>(); /** * 迭代算法 * @param root * @return */ public List<Integer> method2(TreeNode root)
中序遍历
TESE_yan的博客
03-01 1139
利用栈实现非递归遍历，先压栈，压到空时，再弹栈，实现左中右遍历 #include <iostream> #include <vector> #include <algorithm> #include <iterator> #include <stack> struct TreeNode { int val; TreeNode *left; TreeNode *right; TreeNode(int x) : v
【数据结构】N叉树和二叉树
qq_44671773的博客
06-03 1227
I. 阅读前你所需要的基础知识 了解树 (Trees)（不了解的话点我）. II. N叉树 (N-ary Trees) 什么是N叉树：N叉树是一种特殊的树，它具有如下特性 每个非空的节点下都必有N个子节点。 N叉树的节点可以为空 示例分析：下图为一个普通的N叉树，精确来讲是三叉树 (ternary trees) 根节点为A，A为非空节点，则 ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值