数据结构第六章树

好像是脆脆鲨

已于 2023-04-26 10:53:43 修改

阅读量87

点赞数 1

分类专栏：数据结构文章标签：数据结构算法图论

于 2023-04-25 16:31:41 首次发布

本文链接：https://blog.csdn.net/weixin_70463877/article/details/130364530

版权

数据结构专栏收录该内容

9 篇文章 0 订阅

订阅专栏

1.树

1.1树的基本概念

树：是N(N≥0)个结点的有限集合，N=0时，称为空树，这是一种特殊情况。
在这里插入图片描述

对K来说：根结点A到K的唯一路径上的任意结点，称为K的祖先结点。如结点B是K的祖先节点，K是B的子孙结点。路径上最接近K的结点E称为K的双亲结点，K是E的孩子结点。根A是树中唯一没有双亲的结点。有相同双亲的结点称为兄弟节点，如K和L有相同的双亲结点E，即K和L是兄弟结点。
树中一个结点的子结点个数称为该结点的度，树中结点最大度数称为树的度。如B的度为2，但是D的度为3，所以该树的度为3.
度大于0的结点称为分支结点（又称为非终端结点）；度为0（没有子女结点）的结点称为叶子结点（又称终端结点）。在分支结点中，每个结点的分支数就是该节点的度。
路径和路径长度：树中两个结点之间的路径是由这两个节点之间所经过的结点序列构成的，而路径长度是路径上所经过的边的个数。A和K的路径长度为3.路径为B，E。

1.2树的性质

树中结点数等于所有节点的度数+1.
度为m的树中第i层上之多有mi−1个结点(i≥1)
高度为h的m叉树至多有mh−1m−1个结点
具有n个结点的m叉树的最小高度为logm(n(m−1)+1)

2.二叉树

2.1二叉树的定义

二叉树是n(n>=0)个结点的有限集，它或者是空集（n=0），或者由一个根结点及两颗互不相交的分别称作这个根的左子树和右子树的二叉树组成。

2.2二叉树的性质

1.在二叉树的第i层上至多有2^（i-1）个结点（i>1）。
2.深度为k的二叉树至多有2^k-1个结点（k>=1）。
3.对任何一颗二叉树T，如果其叶子数为n0，度为2的结点数为n2，则n0=n2+1.
4. 具有n个结点的完全二叉树的深度为(log2N)+1。
在这里插入图片描述

2.3二叉树的存储结构

2.3.1二叉树的顺序存储

#define MaxSize 100

struct TreeNode{
   ElemType value; //结点中的数据元素
   bool isEmpty;   //结点是否为空
}

main(){
   TreeNode t[MaxSize];
   for (int i=0; i<MaxSize; i++){
      t[i].isEmpty = true;
   }
}

2.3.2二叉树的链式存储

//二叉树的结点

struct ElemType{
   int value;
};

typedef struct BiTnode{
   ElemType data;          //数据域
   struct BiTNode *lchild, *rchild; //左、右孩子指针
}BiTNode, *BiTree;

//定义一棵空树
BiTree root = NULL;

//插入根节点
root = (BiTree) malloc (sizeof(BiTNode));
root -> data = {1};
root -> lchild = NULL;
root -> rchild = NULL;

//插入新结点
BiTNode *p = (BiTree) malloc (sizeof(BiTNode));
p -> data = {2};
p -> lchild = NULL;
p -> rchild = NULL;
root -> lchild = p; //作为根节点的左孩子

在这里插入图片描述

2.4二叉树的遍历

2.4.1遍历基础

遍历定义

指按某条搜索路线遍访每个结点且不重复（又称周游）。

遍历用途

它是树结构插入、删除、修改、查找和排序运算的前提，是二叉树一切运算的基础和核心。

先(前)序遍历: 对访问到的每个结点,先访问根结点,然后是左结点,然后是右结点。

中序遍历: 对访问到的每个结点,先访问左结点,然后是根结点,然后是右结点。

后序遍历: 对访问到的每个结点,先访问左结点,然后是右结点,然后是根结点。
在这里插入图片描述

先序遍历： 1  2  4  5  7  8  3  6

中序遍历： 4  2  7  5  8  1  3  6

后序遍历： 4  7  8  5  2  6  3  1

层次遍历： 1  2  3  4  5  6  7  8

2.4.2遍历实现

先序遍历

typedef struct BiTnode{
   ElemType data;          
   struct BiTNode *lchild, *rchild; 
}BiTNode, *BiTree;

void PreOrder(BiTree T){
   if(T!=NULL){
      visit(T);                 //访问根结点
      PreOrder(T->lchild);      //递归遍历左子树
      PreOrder(T->rchild);      //递归遍历右子树
   }
}

中序遍历

typedef struct BiTnode{
   ElemType data;          
   struct BiTNode *lchild, *rchild; 
}BiTNode, *BiTree;

void InOrder(BiTree T){
   if(T!=NULL){
      InOrder(T->lchild);       //递归遍历左子树
      visit(T);                 //访问根结点
      InOrder(T->rchild);       //递归遍历右子树
   }
}

后序遍历

typedef struct BiTnode{
   ElemType data;          
   struct BiTNode *lchild, *rchild; 
}BiTNode, *BiTree;

void PostOrder(BiTree T){
   if(T!=NULL){
      PostOrder(T->lchild);       //递归遍历左子树    
      PostOrder(T->rchild);       //递归遍历右子树
      visit(T);                 //访问根结点
   }
}

层序遍历：
初始化一个辅助队列
根节点入队
若队列非空，则队头结点出队，访问该结点，依次将其左、右孩子插入队尾（如果有的话）
重复以上操作直至队列为空

//二叉树的结点(链式存储)
typedef struct BiTnode{
   ElemType data;          
   struct BiTNode *lchild, *rchild; 
}BiTNode, *BiTree;

//链式队列结点
typedef struct LinkNode{
   BiTNode * data;
   typedef LinkNode *next;
}LinkNode;

typedef struct{
   LinkNode *front, *rear;  
}LinkQueue;

//层序遍历
void LevelOrder(BiTree T){
   LinkQueue Q;
   InitQueue (Q);          //初始化辅助队列
   BiTree p;
   EnQueue(Q,T);           //将根节点入队
   while(!isEmpty(Q)){     //队列不空则循环
      DeQueue(Q,p);        //队头结点出队
      visit(p);            //访问出队结点
      if(p->lchild != NULL)
         EnQueue(Q,p->lchild);   //左孩子入队
      if(p->rchild != NULL)
         EnQueue(Q,p->rchild);   //右孩子入队
   }
}

2.5线索二叉树

2.5.1线索二叉树的概念与作用

在二叉树的结点上加上线索的二叉树称为线索二叉树，对二叉树以某种遍历方式（如先序、中序、后序或层次等）进行遍历，使其变为线索二叉树的过程称为对二叉树进行线索化。

2.5.2线索二叉树的存储结构

//线索二叉树结点
typedef struct ThreadNode{
   ElemType data;
   struct ThreadNode *lchild, *rchild;
   int ltag, rtag;                // 左、右线索标志
}ThreadNode, *ThreadTree;

2.6恢复二叉树

由先序、中序能确立唯一二叉树
由后序、中序能确立唯一二叉树
由先序、后序不能确立唯一二叉树

2.7二叉树的其他操作

2.7.1建立二叉树

void CreateBiTree(BiTree &T）{
	cin>>ch;
	if (ch==’#’)   
		T=NULL;  	//递归结束，建空树
	else {
	    T=new BiTNode;    
	    T-＞data=ch; 	//生成根结点
	    CreateBiTree(T-＞lchild);  //递归创建左子树
 	    CreateBiTree(T-＞rchild); //递归创建右子树
  }									
}

2.7.2计算结点数

int NodeCount(BiTree T){
	if(T == NULL ) return 0;  			    
	else return NodeCount(T->lchild)+NodeCount(T->rchild)+1;
}

2.7.3计算叶子结点数

int LeadCount(BiTree T){
 	if(T==NULL) 	//如果是空树返回0
		return 0;
	if (T->lchild == NULL && T->rchild == NULL)
		return 1; //如果是叶子结点返回1
	else return LeafCount(T->lchild) + LeafCount(T->rchild);
}

2.7.4计算二叉树深度

int get_deep(tree *p){
    if(p == NULL)
        return 0;
    return max(deep(p->l),deep(p->r))+1;
}

3.树和森林

3.1树的存储结构

3.1.1 双亲表示法(顺序存储)

每个结点中保存指向双亲的指针

数据域：存放结点本身信息。
双亲域：指示本结点的双亲结点在数组中的位置。

#define MAX_TREE_SIZE 100  //树中最多结点数

typedef struct{      //树的结点定义
   ElemType data; 
   int parent;      //双亲位置域
}PTNode;

typedef struct{                   //树的类型定义
   PTNode nodes[MAX_TREE_SIZE];   //双亲表示
   int n;                         //结点数
}PTree;

增：新增数据元素，无需按逻辑上的次序存储；（需要更改结点数n）
删（叶子结点）：① 将伪指针域设置为-1；②用后面的数据填补；（需要更改结点数n）
查询：①优点-查指定结点的双亲很方便；②缺点-查指定结点的孩子只能从头遍历，空数据导致遍历更慢；

3.1.2 孩子表示法(顺序+链式)

孩子链表：把每个结点的孩子结点排列起来，看成是一个线性表，用单链表存储，则n个结点有n个孩子链表（叶子的孩子链表为空表）。而n个头结点又组成一个线性表，用顺序表（含n个元素的结构数组）存储。

struct CTNode{
   int child;    //孩子结点在数组中的位置
   struct CTNode *next;    // 下一个孩子
};

typedef struct{
   ElemType data;
   struct CTNode *firstChild;    // 第一个孩子
}CTBox;

typedef struct{
   CTBox nodes[MAX_TREE_SIZE];
   int n, r;   // 结点数和根的位置
}CTree;

3.1.3 孩子兄弟表示法（链式）

typedef struct CSNode{
   ElemType data;                               //数据域
   struct CSNode *firstchild, *nextsibling;     //第一个孩子和右兄弟指针, *firstchild 看作左指针，*nextsibling看作右指针
}CSNode. *CSTree;