基本数据结构之二叉树

最新推荐文章于 2023-01-07 11:49:30 发布

给思维做按摩

最新推荐文章于 2023-01-07 11:49:30 发布

阅读量799

点赞数 1

分类专栏：经典数据结构实现文章标签：数据结构二叉链表线索化二叉树 n叉树转二叉树

本文链接：https://blog.csdn.net/luozhaowork/article/details/10251345

版权

经典数据结构实现专栏收录该内容

9 篇文章 0 订阅

订阅专栏

1、二叉树

二叉树，顾名思义，有两个树杈，说的更书面一些，有两颗子树，称为左子树和右子树，左子树和右子树分别是二叉树，二叉树是递归定义的，所以二叉树的一些操作都可以用递归的方式来解决。

下面介绍下根据二叉树的定义推出的一些二叉树的基本性质：

1）每个结点至多只有二棵子树(不存在度大于2的结点)，二叉树的子树有左右之分，次序不能颠倒。

2）二叉树的第i层至多有 $2^{i-1}$ 个结点

3）对任何一棵二叉树T，如果其终端结点数为 $n_0$ ，度为2的结点数为 $n_2$ ，则 $n_0=n_2+1$

二叉树又可以分位完全二叉树和满二叉树：

1）满二叉树：一棵深度为k，且有 $2^k-1$ 个节点成为满二叉树

2）完全二叉树：深度为k，有n个节点的二叉树，当且仅当其每一个节点都与深度为k的满二叉树中序号为1至n的节点对应时，称之为完全二叉树

2、存储二叉树的方法

2.1 顺序存储表示

2.1.1 存储结构 && 基本操作

-----------------------------------------------------------------------------------------

/* 二叉树的顺序存储表示 */
 #define MAX_TREE_SIZE 100 /* 二叉树的最大节点数 */
 typedef TElemType SqBiTree[MAX_TREE_SIZE]; /* 0号单元存储根节点 */
 
 typedef struct
 {
   int level,order; /* 节点的层，本层序号(按满二叉树计算) */
 }position;

 
   /* 二叉树的顺序存储的基本操作(23个)*/
 #define ClearBiTree InitBiTree /* 在順序存储结构中，两函数完全一样 */
 #define DestroyBiTree InitBiTree /* 在順序存储结构中，两函数完全一样 */
 void InitBiTree(SqBiTree T) －－－（SqBiTree & T）
 { /* 构造空二叉树T。因为T是数组名，故不需要& */
   int i;
   for(i=0;i<MAX_TREE_SIZE;i++)
     T[i]=Nil; /* 初值为空(Nil在主程中定义) */
 }
 
 

 
   void CreateBiTree(SqBiTree T)
 { /* 按层序次次序入二叉树中结點的值(字符型或整型), 构造顺序存储的二叉树T */
   int i=0;
 #if CHAR /* 结点类型为字符 */
   int l;
   char s[MAX_TREE_SIZE];
   InitBiTree(T); /* 構造空二叉樹T */
   printf("请按层序输入结点的值(字符)，空格表示空结点，结点数≦%d:\n",MAX_TREE_SIZE);
   gets(s); /* 输入字符串 */
   l=strlen(s); /* 求字符串的长度 */
   for(;i<l;i++) /* 将字符串赋值给T */
     T[i]=s[i];
 #else /*结点类型为整型 */
   InitBiTree(T); /* 构造空二叉树 */
   printf("请按层序输入结点的值(字符)，0表示空结点，输999结束。结点数≦%d:\n",MAX_TREE_SIZE);
   while(1)
   {
     scanf("%d",&T[i]);
     if(T[i]==999)
     {
       T[i]=Nil;
       break;
     }
     i++;
   }
 #endif
   for(i=1;i<MAX_TREE_SIZE;i++)
     if(T[(i+1)/2-1]==Nil&&T[i]!=Nil) /* 此非根结点(不空)无双亲 */
     {
       printf("出现无双亲的非根结点"form"\n",T[i]);
       exit(ERROR);
     }
 }
 
 

 
   Status BiTreeEmpty(SqBiTree T)
 { /* 初始条件：二叉树T存在。操作结果：若T为空二叉树，则返回TRUE，否则FALSE */
   if(T[0]==Nil) /* 根结点为空，则树空 */
     return TRUE;
   else
     return FALSE;
 }
 
 

 
   int BiTreeDepth(SqBiTree T)
 { /* 初始条件：二叉树T存在。操作借果：返回T的深度 */
   int i,j=-1;
   for(i=MAX_TREE_SIZE-1;i>=0;i--) /* 找到最后一个结点 */
     if(T[i]!=Nil)
       break;
   i++; /* 为了便于计算 */
   do
     j++;
   while(i>=pow(2,j));   /*pow是原型为double pow( double x, double y ),计算x的y次方,h = log<sub>2</sub>k + 1来计算二叉树的深度*/
   return j;
 }
 
 

 
   Status Root(SqBiTree T,TElemType *e)
 { /* 初始条件：二叉树T存在。操作结果：当T不空，用e返回T的根，返回OK；否则返回ERROR，e无定义 */
   if(BiTreeEmpty(T)) /* T空 */
     return ERROR;
   else
   {
     *e=T[0];
     return OK;
   }
 }
 
 

 
   TElemType Value(SqBiTree T,position e)
 { /* 初始条件：二叉树T存在，e是T中某个结点(的位置) */
   /* 操作结果：返回处于位置e(层,本层序号)的结点的值 */
   return T[(int)pow(2,e.level-1)+e.order-2];
 }
 
 

 
   Status Assign(SqBiTree T,position e,TElemType value)
 { /* 初始条件：二叉树T存在，e是T中某个结点(的位置) */
   /* 操作结果：给处于位置e(层,本层序号)的结点赋新值value */
   int i=(int)pow(2,e.level-1)+e.order-2; /* 将层、本层序号转为矩阵的序号 */
   if(value!=Nil&&T[(i+1)/2-1]==Nil) /* 给叶子赋非空值，但双亲为空 */
     return ERROR;
   else if(value==Nil&&(T[i*2+1]!=Nil||T[i*2+2]!=Nil)) /*  给双亲赋空值但有叶子(不空) */
     return ERROR;
   T[i]=value;
   return OK;
 }
 
 

 
   TElemType Parent(SqBiTree T,TElemType e)
 { /* 初始条件：二叉樹T存在，e是T中某个结点 */
   /* 操作结果：若e是T的非根结点，则返回它的双亲，否则返回＂空＂ */
   int i;
   if(T[0]==Nil) /* 空树 */
     return Nil;
   for(i=1;i<=MAX_TREE_SIZE-1;i++)
     if(T[i]==e) /* 找到e */
       return T[(i+1)/2-1];
   return Nil; /* 沒找到e */
 }
 
 

 
   TElemType LeftChild(SqBiTree T,TElemType e)
 { /* 初始条件：二叉树T存在，e是T中某个结点。操作结果：返回e的左孩子。若e无左孩子,则返回"空" */
   int i;
   if(T[0]==Nil) /* 空树 */
     return Nil;
   for(i=0;i<=MAX_TREE_SIZE-1;i++)
     if(T[i]==e) /* 找到e */
       return T[i*2+1];
   return Nil; /* 沒找到e */
 }
 
 

 
   TElemType RightChild(SqBiTree T,TElemType e)
 { /* 初始条件：二叉树T存在，e是T中某个结点。操作结果：返回e的右孩子。若e无左孩子,则返回"空" */
   int i;
   if(T[0]==Nil) /* 空树 */
     return Nil;
   for(i=0;i<=MAX_TREE_SIZE-1;i++)
     if(T[i]==e) /* 找到e */
       return T[i*2+2];
   return Nil; /* 沒找到e */
 }
 
 

 
   TElemType LeftSibling(SqBiTree T,TElemType e)
 { /* 初始条件：二叉树T存在，e是T中某个结点 */
   /* 操作结果：返回e的左兄弟。若e是T的左孩子或无左兄弟，則返回＂空＂ */
   int i;
   if(T[0]==Nil) /* 空树 */
     return Nil;
   for(i=1;i<=MAX_TREE_SIZE-1;i++)
     if(T[i]==e&&i%2==0) /* 找到e且其序号为偶数(是右孩子) */
       return T[i-1];
   return Nil; /* 沒找到e */
 }
 
 

 
   TElemType RightSibling(SqBiTree T,TElemType e)
 { /* 初始条件：二叉树T存在，e是T中某个结点 */
   /* 操作结果：返回e的右兄弟。若e是T的右孩子或无右兄弟，则返回＂空＂ */
   int i;
   if(T[0]==Nil) /* 空树 */
     return Nil;
   for(i=1;i<=MAX_TREE_SIZE-1;i++)
     if(T[i]==e&&i%2) /* 找到e且其序号为奇数(是左孩子) */
       return T[i+1];
   return Nil; /* 沒找到e */
 }
 
 

 
   void Move(SqBiTree q,int j,SqBiTree T,int i) /* InsertChild()用到。加 */
 { /* 把从q的j结点开始的子树移为从T的i结点开始的子树 */
   if(q[2*j+1]!=Nil) /* q的左子樹不空 */
     Move(q,(2*j+1),T,(2*i+1)); /* 把q的j结点的左子树移为T的i结点的左子樹 */
   if(q[2*j+2]!=Nil) /* q的右子树不空 */
     Move(q,(2*j+2),T,(2*i+2)); /* 把q的j结点的右子树移为T的i结点的右子树 */
   T[i]=q[j]; /* 把q的j结点移为T的i结点 */
   q[j]=Nil; /* 把q的j结点置空 */
 }
 
 

 
   void InsertChild(SqBiTree T,TElemType p,int LR,SqBiTree c)
 { /* 初始条件：二叉树T存在，p是T中某个结点的值，LR为0或1，非空二叉树c与T不相交且右子树为空 */
   /* 操作结果: 根据LR为0或1,插入c为T中p结点的左或右子樹。p结点的原有左或右子树则成为c的右子樹 */
   int j,k,i=0;
   for(j=0;j<(int)pow(2,BiTreeDepth(T))-1;j++) /* 查找p的序号 */
     if(T[j]==p) /* j为p的序号 */
       break;
   k=2*j+1+LR; /* k为p的左或右孩子的序号 */
   if(T[k]!=Nil) /* p原來的左或右孩子不空 */
     Move(T,k,T,2*k+2); /* 把从T的k结点开始的子树移为从k结点的右子树开始的子樹 */
   Move(c,i,T,k); /* 把从c的i结点开始的子树移为从T的k结点开始的子树 */
 }
 
 

 
   typedef int QElemType; /* 设队列元素为整型(序号) */
/* 链队列 *//* 链队列的基本操作 */
 Status DeleteChild(SqBiTree T,position p,int LR)
 { /* 初始条件：二叉树T存在，p指向T中某个结点，LR为1或0 */
   /* 操作结果：根据LR为1或0，刪除T中p所指结点的左或右子树 */
   int i;
   Status k=OK; /* 队列不空的标志 */
   LinkQueue q;
   InitQueue(&q); /* 初始化队列，用于存放待刪除的结点 */
   i=(int)pow(2,p.level-1)+p.order-2; /* 将层，本层的序号转化为矩阵的序号 */
   if(T[i]==Nil) /* 此结点空 */
     return ERROR;
   i=i*2+1+LR; /* 待刪除子树的根结点在矩阵中的序号 */
   while(k)
   {
     if(T[2*i+1]!=Nil) /* 左结点不空 */
       EnQueue(&q,2*i+1); /* 入队左结点的序号 */
     if(T[2*i+2]!=Nil) /* 右结点不空 */
       EnQueue(&q,2*i+2); /* 入队右结点的信序号 */
     T[i]=Nil; /* 刪除此结点 */
     k=DeQueue(&q,&i); /* 队列不空 */
   }
   return OK;
 }
 
 

 
   void(*VisitFunc)(TElemType); /* 函數变量 */
 void PreTraverse(SqBiTree T,int e)
 { /* PreOrderTraverse()调用 */
   VisitFunc(T[e]);
   if(T[2*e+1]!=Nil) /* 左子树不空 */
     PreTraverse(T,2*e+1);
   if(T[2*e+2]!=Nil) /* 右子树不空 */
     PreTraverse(T,2*e+2);
 }
 
 

 
   void PreOrderTraverse(SqBiTree T,void(*Visit)(TElemType))
 { /* 初始条件：二叉树存在，Visit是对结点操作的应用函数 */
   /* 操作结果：先序遍历T，对每个结点调用函数Visit一次且仅一次 */
   VisitFunc=Visit;
   if(!BiTreeEmpty(T)) /* 树不空 */
     PreTraverse(T,0);
   printf("\n");
 }
 
 

 
   void InTraverse(SqBiTree T,int e)
 { /* InOrderTraverse()调用 */
   if(T[2*e+1]!=Nil) /* 左子树不空 */
     InTraverse(T,2*e+1);
   VisitFunc(T[e]);
   if(T[2*e+2]!=Nil) /* 右子树不空 */
     InTraverse(T,2*e+2);
 }
 
 

 
   void InOrderTraverse(SqBiTree T,void(*Visit)(TElemType))
 { /* 初始条件：二叉树存在，Visit是对结点操作的应用函数 */
   /* 操作结果：中序遍历T，对每個结点调用函數Visit一次且仅一次 */
   VisitFunc=Visit;
   if(!BiTreeEmpty(T)) /* 树不空 */
     InTraverse(T,0);
   printf("\n");
 }
 
 

 
   void PostTraverse(SqBiTree T,int e)
 { /* PostOrderTraverse()调用 */
   if(T[2*e+1]!=Nil) /* 左子树不空 */
     PostTraverse(T,2*e+1);
   if(T[2*e+2]!=Nil) /* 右子树不空 */
     PostTraverse(T,2*e+2);
   VisitFunc(T[e]);
 }
 
 

 
   void PostOrderTraverse(SqBiTree T,void(*Visit)(TElemType))
 { /* 初始条件：二叉树T存在，Visit是对结点操作的应用函數 */
   /* 操作结果：后序遍历T，对每個结点应用函數Visit一次且仅一次 */
   VisitFunc=Visit;
   if(!BiTreeEmpty(T)) /* 树不空 */
     PostTraverse(T,0);
   printf("\n");
 }
 
 

 
   void LevelOrderTraverse(SqBiTree T,void(*Visit)(TElemType))
 { /* 层序遍历二叉树 */
   int i=MAX_TREE_SIZE-1,j;
   while(T[i]==Nil)
     i--; /* 找到最后一個非空结点的序号 */
   for(j=0;j<=i;j++) /* 从根节点起，按层序遍历二叉树 */
     if(T[j]!=Nil)
       Visit(T[j]); /* 只遍历非空的结点 */
   printf("\n");
 }
 
 

 
   void Print(SqBiTree T)
 { /* 逐层、按本层序号输出二叉树 */
   int j,k;
   position p;
   TElemType e;
   for(j=1;j<=BiTreeDepth(T);j++)
   {
     printf("第%d层: ",j);
     for(k=1;k<=pow(2,j-1);k++)
     {
       p.level=j;
       p.order=k;
       e=Value(T,p);
       if(e!=Nil)
         printf("%d:"form" ",k,e);
     }
     printf("\n");
   }
 } 
 

2.2 二叉链表存储表示

2.2.1 存储结构 && 基本操作

在使用记录或内存地址指针的编程语言中，二叉树通常用树结点结构来存储。有时也包含指向唯一的父节点的指针。如果一个结点的子结点个数小于2，一些子结点指针可能为空值，或者为特殊的哨兵结点。使用链表能避免顺序储存浪费空间的问题，算法和结构相对简单，但使用二叉链表，由于缺乏父链的指引，在找回父节点时需要重新扫描树得知父节点的节点地址。

typedef struct BiTNode
 {
   TElemType data;
   struct BiTNode *lchild,*rchild; /* 左右孩子指针 */
 }BiTNode,*BiTree;

 /* 操作结果：构造空树T */
void InitTree(CSTree *T)
 {
   *T=NULL;
 }

 /* 初始条件：树T存在。操作结果：销毁树T */
void DestroyTree(CSTree *T)
 {
   if(*T)
   {
     if((*T)->firstchild) /* T有长子 */
       DestroyTree(&(*T)->firstchild); /*销毁T的长子为根结点的子树 */
     if((*T)->nextsibling) /* T有下一个兄弟 */
       DestroyTree(&(*T)->nextsibling); /* 销毁T的下一个兄弟为根节点的子树 */
     free(*T); /* 释放根结点 */
     *T=NULL;
   }
 }
/* 关于队列的操作 参见另一篇博文 ：链队列 */
void CreateTree(CSTree *T)
 { /* 构造树T */
   char c[20]; /* 临时存放孩子结点(设不超过20个)的值 */
   CSTree p,p1;
   LinkQueue q;
   int i,l;
   InitQueue(&q);
   printf("请输入根节点(字符型,空格为空): ");
   scanf("%c%*c",&c[0]);
   if(c[0]!=Nil) /* 非空树 */
   {
     *T=(CSTree)malloc(sizeof(CSNode)); /* 建立根结点 */
     (*T)->data=c[0];
     (*T)->nextsibling=NULL;
     EnQueue(&q,*T); /* 入对根结点的指针 */
     while(!QueueEmpty(q)) /* 队不空 */
     {
       DeQueue(&q,&p); /* 出队一个结点的指針 */
       printf("请按长幼顺序入结点%c的所有孩子: ",p->data);
       gets(c);
       l=strlen(c);
       if(l>0) /* 有孩子 */
       {
         p1=p->firstchild=(CSTree)malloc(sizeof(CSNode)); /* 建立长子结点 */
         p1->data=c[0];
         for(i=1;i<l;i++)
         {
           p1->nextsibling=(CSTree)malloc(sizeof(CSNode)); /* 建立下一个兄弟结点 */
           EnQueue(&q,p1); /* 入队上一个结点 */
           p1=p1->nextsibling;
           p1->data=c[i];
         }
         p1->nextsibling=NULL;
         EnQueue(&q,p1); /* 入对最后一個结点 */
       }
       else
         p->firstchild=NULL; /* 长子指针为空 */
     }
   }
   else
     *T=NULL; /* 空树 */
 }

/* 初始条件：树T存在。操作结果：若T为空树，则返回TURE，否则返回FALSE */
Status TreeEmpty(CSTree T)
 { 
   if(T) /* T不空 */
     return FALSE;
   else
     return TRUE;
 }

int TreeDepth(CSTree T)
 { /* 初始条件：树T存在。操作结果：返回T的深度 */
   CSTree p;
   int depth,max=0;
   if(!T) /* 树空 */
     return 0;
   if(!T->firstchild) /* 树无长子 */
     return 1;
   for(p=T->firstchild;p;p=p->nextsibling)
   { /* 求子树深度的最大值 */
     depth=TreeDepth(p);
     if(depth>max)
       max=depth;
   }
   return max+1; /* 树的深度=子树深度最大值+1 */
 }


/* 返回p所指结点的值 */
TElemType Value(CSTree p)
 { 
   return p->data;
 }

 /* 初始条件：树T存在。操作结果：返回T的根 */
TElemType Root(CSTree T)
 {
   if(T)
     return Value(T);
   else
     return Nil;
 }

/* 返回二叉链表(孩子—兄弟)树T中指向元素值为s的结点的指针。另加 */
CSTree Point(CSTree T,TElemType s)
 { 
   LinkQueue q;
   QElemType a;
   if(T) /* 非空树 */
   {
     InitQueue(&q); /* 初始化队列 */
     EnQueue(&q,T); /* 根节点入队 */
     while(!QueueEmpty(q)) /* 队不空 */
     {
       DeQueue(&q,&a); /* 出队,队列元素赋给a */
       if(a->data==s)
         return a;
       if(a->firstchild) /* 有长子 */
         EnQueue(&q,a->firstchild); /* 入队长子 */
       if(a->nextsibling) /* 有下一个兄弟 */
         EnQueue(&q,a->nextsibling); /* 入队下一个兄弟 */
     }
   }
   return NULL;
 }

/* 初始条件：树T存在，cur_e是树T中结点的值。操作结果：改cur_e为value */
 Status Assign(CSTree *T,TElemType cur_e,TElemType value)
 { 
   CSTree p;
   if(*T) /* 非空树 */
   {
     p=Point(*T,cur_e); /* p为cur_e的指针 */
     if(p) /* 找到cur_e */
     {
       p->data=value; /* 赋新值 */
       return OK;
     }
   }
   return ERROR; /* 树空或沒找到 */
 }

/* 初始条件：树T存在，cur_e是T中某个结点 */
/* 操作结果：若cur_e是T的非根结点，则返回它的双亲，否则函数值为＂空＂*/
TElemType Parent(CSTree T,TElemType cur_e)
 { 
   CSTree p,t;
   LinkQueue q;
   InitQueue(&q);
   if(T) /* 树非空 */
   {
     if(Value(T)==cur_e) /* 根结点值为cur_e */
       return Nil;
     EnQueue(&q,T); /* 根结点入队 */
     while(!QueueEmpty(q))
     {
       DeQueue(&q,&p);
       if(p->firstchild) /* p有长子 */
       {
         if(p->firstchild->data==cur_e) /* 长子为cur_e */
           return Value(p); /* 返回双亲 */
         t=p; /* 双亲指针赋给t */
         p=p->firstchild; /* p指向长子 */
         EnQueue(&q,p); /* 入队长子 */
         while(p->nextsibling) /* 有下一個兄弟 */
         {
           p=p->nextsibling; /* p指向下一個兄弟 */
         if(Value(p)==cur_e) /* 下一個兄弟为cur_e */
         return Value(t); /* 返回双亲 */
         EnQueue(&q,p); /* 入队下一个兄弟 */
         }
       }
     }
   }
   return Nil; /* 树空或沒找到cur_e */
 }

/* 初始条件：树T存在，cur_e是T中某个结点 */
/* 操作结果：若cur_e是T的非叶子结点，则返回它的最左孩子，否则返回＂空＂*/
TElemType LeftChild(CSTree T,TElemType cur_e)
 { 
   CSTree f;
   f=Point(T,cur_e); /* f指向结点cur_e */
   if(f&&f->firstchild) /* 找到结点cur_e且结点cur_e有长子 */
     return f->firstchild->data;
   else
     return Nil;
 }

/* 初始条件：树T存在，cur_e是T中某个结点 */
/* 操作结果：若cur_e有右兄弟，则返回它的右兄弟，否则返回＂空＂*/
 TElemType RightSibling(CSTree T,TElemType cur_e)
 { 
   CSTree f;
   f=Point(T,cur_e); /* f指向结点cur_e */
   if(f&&f->nextsibling) /* 找到结点cur_e且结点cur_e有右兄弟 */
     return f->nextsibling->data;
   else
     return Nil; /* 树空 */
 }

/* 初始条件：树T存在，p指向T中某个结点，1≦i≦p所指结点的度+1，非空树c与T不相交 */
/* 操作结果：插入c为T中p结点的第i棵子树 */
/* 因为p所指结点的地址不会改变，故p不需是引用类型 *
Status InsertChild(CSTree *T,CSTree p,int i,CSTree c)
 { 
   int j;
   if(*T) /* T不空 */
   {
     if(i==1) /* 插入c为p的长子 */
     {
       c->nextsibling=p->firstchild; /* p的原长子现是c的下一个兄弟(c本无兄弟) */
       p->firstchild=c;
     }
     else /* 找插入点 */
     {
       p=p->firstchild; /* 指向p的长子 */
       j=2;
       while(p&&i>j)
       {
         p=p->nextsibling;
         j++;
       }
       if(j==i) /* 找到插入位置 */
       {
         c->nextsibling=p->nextsibling;
         p->nextsibling=c;
       }
       else /* p原有孩子数小于i-1 */
         return ERROR;
     }
     return OK;
   }
   else /* T空 */
     return ERROR;
 }

/* 初始条件：树T存在，p指向T中某个结点，1≦i≦p所指结点的度 */
/* 操作结果：删除T中p所指结点的第i棵子树 */
/* 因为p所指结点的地址不会改变，故p不需是引用类型 *
Status DeleteChild(CSTree *T,CSTree p,int i)
 { 
   CSTree b;
   int j;
   if(*T) /* T不空 */
   {
     if(i==1) /* 刪除长子 */
     {
       b=p->firstchild;
       p->firstchild=b->nextsibling; /* p的原次子现是长子 */
       b->nextsibling=NULL;
       DestroyTree(&b);
     }
     else /* 刪除非长子 */
     {
       p=p->firstchild; /* p指向长子 */
       j=2;
       while(p&&i>j)
       {
         p=p->nextsibling;
         j++;
       }
       if(j==i) /* 找到第i棵子树 */
       {
         b=p->nextsibling;
         p->nextsibling=b->nextsibling;
         b->nextsibling=NULL;
         DestroyTree(&b);
       }
       else /* p原有孩子数小于i */
         return ERROR;
     }
     return OK;
   }
   else
     return ERROR;
 }

void PostOrderTraverse(CSTree T,void(*Visit)(TElemType))
 { /* 后根遍历孩子—兄弟二叉链表结构的树T */
   CSTree p;
   if(T)
   {
     if(T->firstchild) /* 有长子 */
     {
       PostOrderTraverse(T->firstchild,Visit); /* 后根遍历长子子树 */
       p=T->firstchild->nextsibling; /* p指向长子的下一个兄弟 */
       while(p)
       {
         PostOrderTraverse(p,Visit); /* 后根遍历下一個兄弟子树 */
         p=p->nextsibling; /* p指向再下一个兄弟 */
       }
     }
     Visit(Value(T)); /* 最后访问根节点 */
   }
 }
void LevelOrderTraverse(CSTree T,void(*Visit)(TElemType))
 { /* 层序遍历孩子—兄弟二叉链表结构的树T */
   CSTree p;
   LinkQueue q;
   InitQueue(&q);
   if(T)
   {
     Visit(Value(T)); /* 先访问根节点 */
     EnQueue(&q,T); /* 入队根结点的指针 */
     while(!QueueEmpty(q)) /* 队不空 */
     {
       DeQueue(&q,&p); /* 出队一個结点的指针 */
       if(p->firstchild) /* 有长子 */
       {
         p=p->firstchild;
         Visit(Value(p)); /* 访问长子结点 */
         EnQueue(&q,p); /* 入队长子结点的指针 */
         while(p->nextsibling) /* 有下一个兄弟 */
         {
           p=p->nextsibling;
           Visit(Value(p)); /* 访问下一个兄弟 */
           EnQueue(&q,p); /* 入队兄弟结点的指针 */
         }
       }
     }
   }
 }

3、访问二叉树的方法

遍历二叉树：L、D、R分别表示遍历左子树、访问根结点和遍历右子树，则先(根)序遍历二叉树的顺序是DLR，中(根)序遍历二叉树的顺序是LDR，后(根)序遍历二叉树的顺序是LRD。还有按层遍历二叉树。这些方法的时间复杂度都是O(n)，n为结点个数。

如果T2是由有序树T转换而来的二叉树，那么T中结点的前序就是T2中结点的前序，T中结点的后序就是T2中结点的中序。任何一棵二叉树的叶结点在先序、中序和后序遍历中的相对次序不发改变。设n,m为一棵二叉树上的两个结点，在中序遍历时，n在m前的条件是n在m的左方。前序串行和中序串行相同的二叉树为空树或任一结点均无左孩子的非空二叉树；中序串行和后序串行相同的二叉树为空树或任一结点均无右孩子的非空二叉树；前序串行和后序串行相同的二叉树为空树或仅有一个结点的二叉树。

假设我们有一个包含值的value和指向两个子结点的left和right的树结点结构。我们可以写出这样的过程：

visit(node)
    print node.value
    if node.left  != null then visit(node.left)
    if node.right != null then visit(node.right)

这样会用中序打印出树中的值。在中序，每个结点在访问它的子结点之前访问。类似地，如果打印语句在最后，每个结点在访问他的子节点之后访问，树中的值会用后序来打印。在这两种情况中，左子树中的值比右子树中得值先打印。

visit(node)
    if node.left  != null then visit(node.left)
    print node.value
    if node.right != null then visit(node.right)

最后，上面的中序遍历，每个结点在访问左子树和右子树之间访问。这在遍历二叉搜索树时很常用，因为它能用递增的顺序来遍历所有的值。

以上的递归算法使用与树的高度成比例的栈空间。如果我们在每个结点中存储指向父结点的指针，那样可以使用迭代算法，只使用常数空间实现所有这些遍历。然而，指向父结点的指针占用更多的空间。这只在需要指向父节点的指针或栈空间有限时才使用。例如，这是一个中序遍历的迭代算法：

visit(root)
    prev    := null
    current := root
    next    := null
    
    while current != null
        if prev == current.parent
            prev := current
            next := current.left
        if next == null or prev == current.left
            print current.value
            prev := current
            next := current.right
        if next == null or prev == current.right
            prev := current
            next := current.parent
        current := next

用二叉树表示下述表达式：a+b*(c-d)-e/f

先序遍历的串行是：-+a*b-cd/ef
中序遍历的串行是：a+b*c-d-e/f
后序遍历的串行是：abcd-*+ef/-

深度优先遍历

在深度优先级中，我们希望从根结点访问最远的结点。和图的深度优先搜索不同的是，不需记住访问过的每一个结点，因为树中不会有环。前序，中序和后序遍历都是深度优先遍历的特例。

广度优先遍历

和深度优先遍历不同，广度优先遍历会先访问离根节点最近的节点。二叉树的广度优先遍历又称按层次遍历。算法借助队列实现。

4、线索化二叉树

线索二叉树(保留遍历时结点在任一串行的前驱和后继的信息)：若结点有左子树，则其lchild域指示其左孩子，否则令lchild域指示其前驱；若结点有右子树，则其rchild域指示其右孩子，否则令rchild指示其后继。还需在结点结构中增加两个标志域LTag和RTag。LTag=0时，lchild域指示结点的左孩子，LTag=1时，lchild域指示结点的前驱；RTag=0时，rchild域指示结点的右孩子，RTag=1时，rchild域指示结点的后继。以这种结点结构构成的二叉链表作为二叉树的存储结构，叫做线索链表，其中指向结点前驱和后继的指针叫做线索，加上线索的二叉树称为线索二叉树。对二叉树以某种次序遍历使其变为线索二叉树的过程叫做线索化。若对二叉树进行中序遍历，则所得的线索二叉树称为中序线索二叉树，线索链表称为为中序线索链表。线索二叉树是一种物理结构。

在中序线索树找结点后继的规律是：若其右标志为1，则右链为线索，指示其后继，否则遍历其右子树时访问的第一个结点（右子树最左下的结点）为其后继；找结点前驱的规律是：若其左标志为1，则左链为线索，指示其前驱，否则遍历左子树时最后访问的一个结点（左子树中最右下的结点）为其前驱。
在后序线索树中找到结点的后继分三种情况：

若结点是二叉树的根，则其后继为空；
若结点是其双亲的右孩子，或是其双亲的左孩子且其双亲没有右子树，则其后继即为双亲结点；
若结点是其双亲的左孩子，且其双亲有右子树，则其后继为双亲右子树上按后序遍历列出的第一个结点。

4.1 二叉树的二叉线索存储表示

在线索链表上添加一个头结点，并令其lchild域的指针指向二叉树的根结点，其rchild域的指针指向中序遍历时访问的最后一个结点。令二叉树中序串行中的第一个结点的lchild域指针和最后一个结点的rchild域的指针均指向头结点，这样就创建了一个双向线索链表.

4.2基本操作

/* 二叉树的二叉线索存储的基本操作 */
 void CreateBiThrTree(BiThrTree *T)
 { /* 按先序输入线索二叉树中结点的值，构造线索二叉树T。0(整型)/空格(字符型)表示空结点 */
   TElemType ch;
   scanf(form,&ch);
   if(ch==Nil)
     *T=NULL;
   else
   {
     *T=(BiThrTree)malloc(sizeof(BiThrNode)); /* 生成根结点(先序) */
     if(!*T)
       exit(OVERFLOW);
     (*T)->data=ch; /* 给根结点赋植 */
     CreateBiThrTree(&(*T)->lchild); /* 递归构造左子树 */
     if((*T)->lchild) /* 有左孩子 */
       (*T)->LTag=Link; /* 给左标志赋值(指针) */
     CreateBiThrTree(&(*T)->rchild); /* 递归构造右子树 */
     if((*T)->rchild) /* 有右孩子 */
       (*T)->RTag=Link; /* 给右标志赋值(指针) */
   }
 }

 
 BiThrTree pre; /* 全局变量，始终指向刚刚访问过的结点 */
 void InThreading(BiThrTree p)
 { /* 通过中序遍历进行中序线索化，线索化之后pre指向最后一个结点。算法6.7 */
   if(p) /* 线索二叉树不空 */
   {
     InThreading(p->lchild); /* 递归左子树线索化 */
     if(!p->lchild) /* 没有左孩子 */
     {
       p->LTag=Thread; /* 左标志为线索(前驱) */
       p->lchild=pre; /* 左孩子指针指向前驱 */
     }
     if(!pre->rchild) /* 前驱没有右孩子 */
     {
       pre->RTag=Thread; /* 前驱的右标志为线索(后继) */
       pre->rchild=p; /* 前驱右孩子指针指向其后继(当前结点p) */
     }
     pre=p; /* 保持pre指向p的前驱 */
     InThreading(p->rchild); /* 递归右子树线索化 */
   }
 }

void InOrderThreading(BiThrTree *Thrt,BiThrTree T)
 { /* 中序遍历二叉树T，并将其中序线索化，Thrt指向头结点。算法6.6 */
   *Thrt=(BiThrTree)malloc(sizeof(BiThrNode));
   if(!*Thrt) /* 生成头结点不成功 */
     exit(OVERFLOW);
   (*Thrt)->LTag=Link; /* 建头结点，左标志为指针 */
   (*Thrt)->RTag=Thread; /* 右标志为线索 */
   (*Thrt)->rchild=*Thrt; /* 右指针回指 */
   if(!T) /* 若二叉树空，则左指针回指 */
     (*Thrt)->lchild=*Thrt;
   else
   {
     (*Thrt)->lchild=T; /* 头结点的左指针指向根结点 */
     pre=*Thrt; /* pre(前驱)的初值指向头结点 */
     InThreading(T); /* 中序遍历进行中序线索化，pre指向中序遍历的最后一个结点 */
     pre->rchild=*Thrt; /* 最后一个结点的右指针指向头结点 */
     pre->RTag=Thread; /* 最后一个结点的右标志为线索 */
     (*Thrt)->rchild=pre; /* 头结点的右指针指向中序遍历的最后一个结点 */
   }
 }

 void InOrderTraverse_Thr(BiThrTree T,void(*Visit)(TElemType))
 { /* 中序遍历线索二叉树T(头结点)的非递归算法。算法6.5 */
   BiThrTree p;
   p=T->lchild; /* p指向根结点 */
   while(p!=T)
   { /* 空树或遍历结束时，p==T */
     while(p->LTag==Link) /* 由根结点一直找到二叉树的最左结点 */
       p=p->lchild;
     Visit(p->data); /* 访问此结点 */
     while(p->RTag==Thread&&p->rchild!=T) /* p->rchild是线索(后继)，且不是遍历的最后一个结点 */
     {
       p=p->rchild;
       Visit(p->data); /* 访问后继结点 */
     }
     p=p->rchild; /* 若p->rchild不是线索(是右孩子)，p指向右孩子，返回循环，*/
   }              /* 找这棵子树中序遍历的第1个结点 */
 }

 void PreThreading(BiThrTree p)
 { /* PreOrderThreading()调用的递归函数 */
   if(!pre->rchild) /* p的前驱没有右孩子 */
   {
     pre->rchild=p; /* p前驱的后继指向p */
     pre->RTag=Thread; /* pre的右孩子为线索 */
   }
   if(!p->lchild) /* p没有左孩子 */
   {
     p->LTag=Thread; /* p的左孩子为线索 */
     p->lchild=pre; /* p的左孩子指向前驱 */
   }
   pre=p; /* 移动前驱 */
   if(p->LTag==Link) /* p有左孩子 */
     PreThreading(p->lchild); /* 对p的左孩子递归调用preThreading() */
   if(p->RTag==Link) /* p有右孩子 */
     PreThreading(p->rchild); /* 对p的右孩子递归调用preThreading() */
 }

 void PreOrderThreading(BiThrTree *Thrt,BiThrTree T)
 { /* 先序线索化二叉树T，头结点的右指针指向先序遍历的最后1个结点 */
   *Thrt=(BiThrTree)malloc(sizeof(BiThrNode));
   if(!*Thrt) /* 生成头结点 */
     exit(OVERFLOW);
   (*Thrt)->LTag=Link; /* 头结点的左指针为孩子 */
   (*Thrt)->RTag=Thread; /* 头结点的右指针为线索 */
   (*Thrt)->rchild=*Thrt; /* 头结点的右指针指向自身 */
   if(!T) /* 空树 */
     (*Thrt)->lchild=*Thrt; /* 头结点的左指针也指向自身 */
   else
   { /* 非空树 */
     (*Thrt)->lchild=T; /* 头结点的左指针指向根结点 */
     pre=*Thrt; /* 前驱为头结点 */
     PreThreading(T); /* 从头结点开始先序递归线索化 */
     pre->rchild=*Thrt; /* 最后一个结点的后继指向头结点 */
     pre->RTag=Thread;
     (*Thrt)->rchild=pre; /* 头结点的后继指向最后一个结点 */
   }
 }

 void PreOrderTraverse_Thr(BiThrTree T,void(*Visit)(TElemType))
 { /* 先序遍历线索二叉树T(头结点)的非递归算法 */
   BiThrTree p=T->lchild; /* p指向根结点 */
   while(p!=T) /* p没指向头结点(遍历的最后1个结点的后继指向头结点) */
   {
     Visit(p->data); /* 访问根结点 */
     if(p->LTag==Link) /* p有左孩子 */
       p=p->lchild; /* p指向左孩子(后继) */
     else /* p无左孩子 */
       p=p->rchild; /* p指向右孩子或后继 */
   }
 }

 void PostThreading(BiThrTree p)
 { /* PostOrderThreading()调用的递归函数 */
   if(p) /* p不空 */
   {
     PostThreading(p->lchild); /* 对p的左孩子递归调用PostThreading() */
     PostThreading(p->rchild); /* 对p的右孩子递归调用PostThreading() */
     if(!p->lchild) /* p没有左孩子 */
     {
       p->LTag=Thread; /* p的左孩子为线索 */
       p->lchild=pre; /* p的左孩子指向前驱 */
     }
     if(!pre->rchild) /* p的前驱没有右孩子 */
     {
       pre->RTag=Thread; /* p前驱的右孩子为线索 */
       pre->rchild=p; /* p前驱的后继指向p */
     }
     pre=p; /* 移动前驱 */
   }
 }

void PostOrderThreading(BiThrTree *Thrt,BiThrTree T)
 { /* 后序递归线索化二叉树 */
   *Thrt=(BiThrTree)malloc(sizeof(BiThrNode));
   if(!*Thrt) /* 生成头结点 */
     exit(OVERFLOW);
   (*Thrt)->LTag=Link; /* 头结点的左指针为孩子 */
   (*Thrt)->RTag=Thread; /* 头结点的右指针为线索 */
   if(!T) /* 空树 */
     (*Thrt)->lchild=(*Thrt)->rchild=*Thrt; /* 头结点的左右指针指向自身 */
   else
   { /* 非空树 */
     (*Thrt)->lchild=(*Thrt)->rchild=T; /* 头结点的左右指针指向根结点(最后一个结点) */
     pre=*Thrt; /* 前驱为头结点 */
     PostThreading(T); /* 从头结点开始后序递归线索化 */
     if(pre->RTag!=Link) /* 最后一个结点没有右孩子 */
     {
       pre->rchild=*Thrt; /* 最后一个结点的后继指向头结点 */
       pre->RTag=Thread;
     }
   }
 }

 void DestroyBiTree(BiThrTree *T)
 { /* DestroyBiThrTree调用的递归函数，T指向根结点 */
   if(*T) /* 非空树 */
   {
     if((*T)->LTag==0) /* 有左孩子 */
       DestroyBiTree(&(*T)->lchild); /* 销毁左孩子子树 */
     if((*T)->RTag==0) /* 有右孩子 */
       DestroyBiTree(&(*T)->rchild); /* 销毁右孩子子树 */
     free(*T); /* 释放根结点 */
     T=NULL; /* 空指针赋0 */
   }
 }

 void DestroyBiThrTree(BiThrTree *Thrt)
 { /* 初始条件：线索二叉树Thrt存在。操作结果：销毁线索二叉树Thrt */
   if(*Thrt) /* 头结点存在 */
   {
     if((*Thrt)->lchild) /* 根结点存在 */
       DestroyBiTree(&(*Thrt)->lchild); /* 递归销毁头结点lchild所指二叉树 */
     free(*Thrt); /* 释放头结点 */
     *Thrt=NULL; /* 线索二叉树Thrt指针赋0 */
   }
 }

5、将n叉树转换为2×树

一般有序树和二叉树之间有一一映射关系，能进行相互转换。n叉树转换为二叉树的方法：二叉树中结点x的左子结点为n叉树中结点x的左子结点；二叉树中结点x的右子结点为n叉树中结点x的第一个右边的同级结点y。

例如，在左边的树中，A有6个子结点{B,C,D,E,F,G}。它能被转换成右边的二叉树。

将n叉树转换为二叉树的例子

将一棵树转换为二叉树的方法：

在兄弟之间加一连接；
对每个结点，除了其左孩子外，去除其与其余孩子之间的联系；
以树的根结点为轴心，将整树顺时针转45度。

给思维做按摩

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
基本数据结构之二叉树

1、二叉树二叉树，顾名思义，有两个树杈，说的更书面一些，有两颗子树，称为左子树和右子树，左子树和右子树分别是二叉树，二叉树是递归定义的，所以二叉树的一些操作都可以用递归的方式来解决。下面介绍下根据二叉树的定义推出的一些二叉树的基本性质：1）每个结点至多只有二棵子树(不存在度大于2的结点)，二叉树的子树有左右之分，次序不能颠倒。2）二叉树的第i层至多有个结点3）对任
复制链接

扫一扫