数据结构二叉树处理.docx

数据结构二叉树处理.docx

《数据结构二叉树处理.docx》由会员分享，可在线阅读，更多相关《数据结构二叉树处理.docx（16页珍藏版）》请在冰豆网上搜索。

数据结构二叉树处理

//二叉树处理头文件

//包括二叉树的结构定义,二叉树的创建,遍历算法（递归及非递归）

1, 内容：

完成二叉树创建,二叉树的前,中,后序遍历（递归）

2. 内容：

完成二叉树的前,中序遍历（非递归）

 3. 内容：

完成查找二叉树的静,动态查找（非递归）

#include"stdlib.h"

#defineMAXNODE20

#defineISIZE8

#defineNSIZE07

#defineNSIZE18

#defineNSIZE215

//SHOWCHAR=1（显示字符） SHOWCHAR=0（显示数字）

#defineSHOWCHAR1

//二叉树结构体

structBTNode

{ intdata;

BTNode*rchild;

 BTNode*lchild;};

//非递归二叉树遍堆栈

structABTStack{

 BTNode*ptree;

 ABTStack*link;

};

charTreeNodeS[NSIZE0]={'A','B','C','D','E','F','G'};

charPreNode[NSIZE0]={'A','B','D','E','C','F','G'};

charMidNode[NSIZE0]={'D','B','E','A','C','G','F'};

intTreeNodeN0[NSIZE1][2]={{0,0},{1,1},{2,2},{3,3},{4,4},{5,5},{6,6},{7,7}};

intTreeNodeN1[NSIZE1][2]={{0,0},{4,1},{2,2},{6,3},{1,4},{3,5},{5,6},{7,7}};

intTreeNode0[NSIZE1][2]={{'0',0},{'D',1},{'B',2},{'F',3},{'A',4},{'C',5},{'E',6},{'G',7}};

intTreeNode1[NSIZE1][2]={{'0',0},{'A',1},{'B',2},{'C',3},{'D',4},{'E',5},{'F',6},{'G',7}};

intTreeNode2[NSIZE2][2]={{'0',0},{'A',1},{'B',2},{'C',3},{'D',4},{'E',5},{'F',6},{'G',7},{'H',8},{'I',9},{'J',10},{'K',11},{'L',12},{'M',13},{'N',14}};

intInsertNode[ISIZE]={-10,-8,-5,-1,0,12,14,16};

//char*prestr="ABDECFG";

//char*midstr="DBEACGF";

/* 二叉树创建函数dCreateBranchTree1（）<递归算法> 参数描述：

  intarray[]:

 二叉树节点数据域数组  inti:

   当前节点的序号  intn:

   二叉树节点个数 返回值:

  dCreateBranchTree1=新建二叉树的根节点指针 

备注:

  根节点=array[（i+j）/2];  

左子节点=[array[i],array[（i+j）2-1]]  

右子节点=[array[（i+j）/2+1,array[j]]*/

BTNode*dCreateBranchTree1（chararray[],inti,intn）

{ BTNode*p; /*二叉树节点*/

 if（i>=n）

  return（NULL）;

 p=（BTNode*）malloc（sizeof（BTNode））;

 p->data=array[i];

 p->lchild=dCreateBranchTree1（array,2*i+1,n）;

 p->rchild=dCreateBranchTree1（array,2*i+2,n）;

 return（p）;

}

/* 二叉树创建函数dCreateBranchTree2（）<递归算法> 参数描述：

  intarray[]:

 二叉树节点数据域数组  inti:

   当前节点的序号  intn:

   二叉树节点个数 返回值:

  dCreateBranchTree2=新建二叉树的根节点指针

 备注:

  根节点=array[（i+j）/2];

  左子节点=[array[i],array[（i+j）2-1]]

  右子节点=[array[（i+j）/2+1,array[j]]

*/

BTNode*dCreateBranchTree2（chararray[],inti,intj）

{

 BTNode*p; /*二叉树节点*/

 if（i>j）

  return（NULL）;

 p=（BTNode*）malloc（sizeof（BTNode））;

 p->data=array[（i+j）/2];

 p->lchild=dCreateBranchTree2（array,i,（i+j）/2-1）;

 p->rchild=dCreateBranchTree2（array,（i+j）/2+1,j）;

 return（p）;

}

/*

 二叉树创建函数dCreateBranchTree3（）<非递归算法>

 已知二叉树的前,中序遍历序列串,构造对应的二叉树

 <编程思想>:

  首先,在前序遍历序列中的首元素是二叉树的根节点,接着 ,在中序遍历序列中找到此节点,那么在此节点以前的节点必为 其左孩子节点,以后的必为其右孩子节点;  然后,在中序遍历序列中,根节点的左子树和右子树再分别 对应子树前序遍历序列的首字符确定子树的根节点,再由中序 遍历序列中根节点的位置分别确定构成它们的左子树和右子树 的节点;  依次类推,确定二叉树的全部节点,构造出二叉树. 参数描述：

  char*pre:

  前序遍历序列

  char*mid:

  中序遍历序列

  intn:

   遍历序列中节点个数

 返回值:

  dCreateBranchTree3=新建二叉树的根节点指针

*/

BTNode*dCreateBranchTree3（char*pre,char*mid,intn）

{

 BTNode*p;

 char*t;

 intleft;

 if（n<=0）

  return（NULL）;

 p=（BTNode*）malloc（sizeof（BTNode））;

 p->data=*pre;

 for（t=mid;t

  if（*t==*pre） break;  /*在中序遍历序列中查找根节点*/

 left=t-mid;  /*左子树的节点个数*/

 p->lchild=dCreateBranchTree3（pre+1,t,left）;

 p->rchild=dCreateBranchTree3（pre+1+left,t+1,n-1-left）;

 return（p）;

}

/* 二叉树创建函数CreateBranchTree（）<非递归算法>

 参数描述：

  intarray[]:

 二叉树节点数据域数组

  intn:

   二叉树节点个数

 返回值:

  CreateBranchTree=新建二叉树的根节点指针

*/

BTNode*CreateBranchTree（intarray[][2],intn）

{ BTNode*head,*p;

 BTNode*NodeAddr[MAXNODE]; //节点地址临时缓冲区

 inti,norder,rorder;

 head=NULL;

 printf（"二叉树原始数据<新建顺序>：

\t"）;

 for（i=1;i<=n;i++）

 {

  p=（BTNode*）malloc（sizeof（BTNode））;

  if（p==NULL）

  {

   printf（"新建节点时内存溢出！

"）;

   return（NULL）;

  }

  Else

  {   p->data=array[i][0];

   p->lchild=p->rchild=NULL;

   norder=array[i][1];

   NodeAddr[norder]=p;

   if（norder>1）

   {

rorder=norder/2; /*非根节点:

挂接在自己的父节点上*/

    if（norder%2==0）

     NodeAddr[rorder]->lchild=p;

    Else

     NodeAddr[rorder]->rchild=p;

   }

   Else

    head=p; /*根节点*/

   if（SHOWCHAR）

    printf（"%c   ",p->data）;

   else

    printf（"%d   ",p->data）;

  }

 }

 return（head）;

}

//------------------------------递归部分------------------------------

/* 二叉树前序遍历函数dpre_Order_Access（）<递归算法> 参数描述：

  BTNode*head:

 二叉树的根节点指针 */

voiddpre_Order_Access（BTNode*head）

{ if（head!

=NULL）

 {

  if（SHOWCHAR）

   printf（"%c   ",head->data）;

  else

   printf（"%d   ",head->data）;

  dpre_Order_Access（head->lchild）; /*递归遍历左子树*/

  dpre_Order_Access（head->rchild）; /*递归遍历右子树*/

 }

}/*

 二叉树中序遍历函数dmid_Order_Access（）<递归算法>

 参数描述：

  BTNode*head:

 二叉树的根节点指针  

*/

voiddmid_Order_Access（BTNode*head）

{

 if（head!

=NULL）

 {

  dmid_Order_Access（head->lchild）; /*递归遍历左子树*/

  if（SHOWCHAR）

   printf（"%c   ",head->data）;

  else

   printf（"%d   ",head->data）;

  dmid_Order_Access（head->rchild）; /*递归遍历右子树*/

 }

}

/*

二叉树后序遍历函数dlast_Order_Access（）<递归算法>

 参数描述：

  BTNode*head:

 二叉树的根节点指针 

*/voiddlast_Order_Access（BTNode*head）

{

 if（head!

=NULL）

 {  dlast_Order_Access（head->lchild）; /*递归遍历左子树*/

  dlast_Order_Access（head->rchild）; /*递归遍历右子树*/

  if（SHOWCHAR）

   printf（"%c   ",head->data）;

  else

   printf（"%d   ",head->data）;

 }

}

//------------------------------递归部分------------------------------

//------------------------------非递归部分------------------------------

/*

 二叉树前序遍历函数pre_Order_Access（）<非递归算法>

 参数描述：

  BTNode*head:

 二叉树的根节点指针  

*/

voidpre_Order_Access（BTNode*head）{

 BTNode*pt;

 ABTStack*ps,*top;

 pt=head;

 top=NULL;

 printf（"二叉树的前序遍历结果<非递归>：

\t"）;

 while（pt!

=NULL||top!

=NULL）  /*二叉树未遍历完,或堆栈非空*/

 {

  while（pt!

=NULL）

  {

   if（SHOWCHAR）

    printf（"%c   ",pt->data）;  /*访问根节点*/

   else

    printf（"%d   ",pt->data）;  /*访问根节点*/

   ps=（ABTStack*）malloc（sizeof（ABTStack））;  /*根节点进栈*/

   ps->ptree=pt;

   ps->link=top;

   top=ps;

   pt=pt->lchild; /*遍历节点右子树,经过的节点依次进栈*/

  }

  if（top!

=NULL）

  {

   pt=top->ptree; /*栈顶节点出栈*/

   ps=top;

   top=top->link;

   free（ps）; /*释放栈顶节点空间*/

   pt=pt->rchild; /*遍历节点右子树*/

  }

 }

}

/*

 二叉树中序遍历函数mid_Order_Access（）<非递归算法>

 参数描述：

  BTNode*head:

 二叉树的根节点指针 

*/

voidmid_Order_Access（BTNode*head）

{

 BTNode*pt;

 ABTStack*ps,*top;

 intcounter=1;

 pt=head;

 top=NULL;

 printf（"二叉树的中序遍历结果<非递归>：

\t"）;

 while（pt!

=NULL||top!

=NULL）  /*二叉树未遍历完,或堆栈非空*/

 {

  while（pt!

=NULL）

  { 

   ps=（ABTStack*）malloc（sizeof（ABTStack））; /*根节点进栈*/

   ps->ptree=pt;

   ps->link=top;

   top=ps;

   pt=pt->lchild; /*遍历节点右子树,经过的节点依次进栈*/

  }

  if（top!

=NULL）  

{

   pt=top->ptree; /*栈顶节点出栈*/

   ps=top;

   top=top->link;

   free（ps）; /*释放栈顶节点空间*/

   if（SHOWCHAR）

    printf（"%c   ",pt->data）; /*访问根节点*/

   else

    printf（"%d   ",pt->data）; /*访问根节点*/

   pt=pt->rchild; /*遍历节点右子树*/

  }

 }

}

/*

 二叉树后序遍历函数last_Order_Access（）<非递归算法>

 参数描述：

  BTNode*head:

 二叉树的根节点指针  

*/

voidlast_Order_Access（BTNode*head）

{

 BTNode*pt;

 ABTStack*ps,*top;

 intcounter=1;

 pt=head;

 top=NULL;

 printf（"二叉树的后序遍历结果<非递归>：

\t"）;

 while（pt!

=NULL||top!

=NULL）  /*二叉树未遍历完,或堆栈非空*/

 {

  while（pt!

=NULL）

  {  

   ps=（ABTStack*）malloc（sizeof（ABTStack））; /*根节点进栈*/

   ps->ptree=pt;

   ps->link=top;

   top=ps;

   pt=pt->lchild; /*遍历节点右子树,经过的节点依次进栈*/

  }

  if（top!

=NULL）

  {

   pt=top->ptree; /*栈顶节点出栈*/

   ps=top;

   top=top->link;

   free（ps）; /*释放栈顶节点空间*/

   printf（"%c   ",pt->data）; /*访问根节点*/

   pt=pt->rchild; /*遍历节点右子树*/

  }

 }

}

/* 二叉查找树静态查找函数static_Search_STree（）<非递归算法>

 参数描述：

  BTNode*head:

 二叉查找树的根节点指针

  intkey:

  查找关键码

 返回值:

  static_Search_STree=键值为key的节点指针（找到）

  static_Search_STree=NULL（没有找到）

*/

BTNode*static_Search_STree（BTNode*head,intkey）

{

 while（head!

=NULL）

 {

  if（head->data==key）

  {

   printf（"数据域=%d\t地址=%d\t",head->data,head）;

   return（head）; /*找到*/

  }

  if（head->data>key）

   head=head->lchild; /*继续沿左子树搜索*/

  else

   head=head->rchild; /*继续沿右子树搜索*/

 }

 return（NULL）; /*没有查找*/

}

/*

 二叉查找树动态查找函数dynamic_Search_STree（）<非递归算法>

 参数描述：

  BTNode*head:

  二叉查找树的根节点指针

  BTNode**parent:

 键值为key的节点的父节点指针的指针

  BTNode**head:

  键值为key的节点指针的指针（找到）或NULL（没有找到）

  intkey:

   查找关键码

 注意:

  *parent==NULL且*p==NULL 没有找到（二叉树为空）

  *parent==NULL且*p!

=NULL 找到（找到根节点）

  *parent!

=NULL且*p==NULL 没有找到（叶节点）<可在parent后插入节点>

  *parent!

=NULL且*p!

=NULL 找到（中间层节点）

*/

voiddynamic_Search_STree（BTNode*head,BTNode**parent,BTNode**p,intkey）

{

 *parent=NULL;

 *p=head;

 while（*p!

=NULL）

 {

  if（（*p）->data==key）

   return; /*找到*/

  *parent=*p; /*以当前节点为父,继续查找*/

  if（（*p）->data>key）

   *p=（*p）->lchild; /*继续沿左子树搜索*/

  Else

   *p=（*p）->rchild; /*继续沿右子树搜索*/

 }

}

/*

 二叉查找树插入节点函数Insert_Node_STree（）<非递归算法>

 参数描述：

  BTNode*head:

 二叉查找树的根节点指针

  intkey:

  查找关键码

 返回值:

  Insert_Node_STree=1 插入成功

  Insert_Node_STree=0 插入失败（节点已经存在）

*/

intInsert_Node_STree（BTNode*head,intkey）

{

 BTNode*p,*q,*nnode;

 dynamic_Search_STree（head,&p,&q,key）;

 if（q!

=NULL）

  return（0）;  /*节点在树中已经存在*/

 nnode=（BTNode*）malloc（sizeof（BTNode））; /*新建节点*/

 nnode->data=key;

 nnode->lchild=nnode->rchild=NULL;

 if（p==NULL）

  head=p; /*原树为空,新建节点为查找树*/

 else

 {

  if（p->data>key）

   p->lchild=nnode; /*作为左孩子节点*/

  else

   p->rchild=nnode; /*作为右孩子节点*/

 }

 return

（1）; /*插入成功*/

}

/*

 二叉查找树插入一批节点函数Insert_Batch_Node_STree（）<非递归算法>

 参数描述：

  BTNode*head:

 二叉查找树的根节点指针

  intarray[]:

 被插入的数据域数组

  intn:

   被插入的节点数目

*/

voidInsert_Batch_Node_STree（BTNode*head,intarray[],intn）

{

 inti;

 for（i=0;i

 {

  if（!

Insert_Node_STree（head,array[i]））

   printf（"插入失败<键值为%d的节点已经存在>！

",array[i]）; 

 }

}

//------------------------------非递归部分------------------------------