二叉树创建及遍历算法(递归及非递归)

原创 2007年10月12日 19:08:00

 

//二叉树处理头文件
//包括二叉树的结构定义,二叉树的创建,遍历算法(递归及非递归),
/*
 作者:成晓旭
 时间:2001年10月7日(18:49:38-20:00:00)
 内容:完成二叉树创建,二叉树的前,中,后序遍历(递归)
 时间:2001年10月7日(21:09:38-22:09:00)
 内容:完成二叉树的前,中序遍历(非递归)
 时间:2001年10月8日(10:09:38-11:29:00)
 内容:完成查找二叉树的静,动态查找(非递归)
*/
#include "stdlib.h"

#define MAXNODE 20
#define ISIZE 8
#define NSIZE0 7
#define NSIZE1 8
#define NSIZE2 15
//SHOWCHAR = 1(显示字符) SHOWCHAR = 0(显示数字)
#define SHOWCHAR 1
//二叉树结构体
struct BTNode
{
 int data;
 BTNode *rchild;
 BTNode *lchild;
};
//非递归二叉树遍堆栈
struct ABTStack
{
 BTNode *ptree;
 ABTStack *link;
};
char TreeNodeS[NSIZE0] = {'A','B','C','D','E','F','G'};
char PreNode[NSIZE0] = {'A','B','D','E','C','F','G'};
char MidNode[NSIZE0] = {'D','B','E','A','C','G','F'};
int TreeNodeN0[NSIZE1][2] = {{0,0},{1,1},{2,2},{3,3},{4,4},{5,5},{6,6},{7,7}};
int TreeNodeN1[NSIZE1][2] = {{0,0},{4,1},{2,2},{6,3},{1,4},{3,5},{5,6},{7,7}};
int TreeNode0[NSIZE1][2] = {{'0',0},{'D',1},{'B',2},{'F',3},{'A',4},{'C',5},{'E',6},{'G',7}};
int TreeNode1[NSIZE1][2] = {{'0',0},{'A',1},{'B',2},{'C',3},{'D',4},{'E',5},{'F',6},{'G',7}};
int TreeNode2[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}};
int InsertNode[ISIZE] = {-10,-8,-5,-1,0,12,14,16};
//char *prestr = "ABDECFG";
//char *midstr = "DBEACGF";
/*
 二叉树创建函数dCreateBranchTree1()<递归算法>
 参数描述:
  int array[]: 二叉树节点数据域数组
  int i:   当前节点的序号
  int n:   二叉树节点个数
 返回值:
  dCreateBranchTree1 = 新建二叉树的根节点指针
 备注:
  根节点 = array[(i+j)/2];
  左子节点 = [array[i],array[(i+j)2-1]]
  右子节点 = [array[(i+j)/2+1,array[j]]
*/
BTNode *dCreateBranchTree1(char array[],int i,int n)
{
 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()<递归算法>
 参数描述:
  int array[]: 二叉树节点数据域数组
  int i:   当前节点的序号
  int n:   二叉树节点个数
 返回值:
  dCreateBranchTree2 = 新建二叉树的根节点指针
 备注:
  根节点 = array[(i+j)/2];
  左子节点 = [array[i],array[(i+j)2-1]]
  右子节点 = [array[(i+j)/2+1,array[j]]
*/
BTNode *dCreateBranchTree2(char array[],int i,int j)
{
 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:  中序遍历序列
  int n:   遍历序列中节点个数
 返回值:
  dCreateBranchTree3 = 新建二叉树的根节点指针
*/
BTNode *dCreateBranchTree3(char *pre,char *mid,int n)
{
 BTNode *p;
 char *t;
 int left;
 if(n<=0)
  return(NULL);
 p = (BTNode *)malloc(sizeof(BTNode));
 p->data = *pre;
 for(t=mid;t<mid+n;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()<非递归算法>
 参数描述:
  int array[]: 二叉树节点数据域数组
  int n:   二叉树节点个数
 返回值:
  CreateBranchTree = 新建二叉树的根节点指针
*/
BTNode *CreateBranchTree(int array[][2],int n)
{
 BTNode *head,*p;
 BTNode *NodeAddr[MAXNODE]; //节点地址临时缓冲区
 int i,norder,rorder;
 head = NULL;
 printf("二叉树原始数据<新建顺序>:/t");
 for(i=1;i<=n;i++)
 {
  p = (BTNode *)malloc(sizeof(BTNode));
  if(p==NULL)
  {
   printf("/n新建节点时内存溢出!/n");
   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: 二叉树的根节点指针  
*/
void dpre_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: 二叉树的根节点指针  
*/
void dmid_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: 二叉树的根节点指针  
*/
void dlast_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: 二叉树的根节点指针  
*/
void pre_Order_Access(BTNode *head)
{
 BTNode *pt;
 ABTStack *ps,*top;
 pt = head;
 top = NULL;
 printf("/n二叉树的前序遍历结果<非递归>:/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: 二叉树的根节点指针 
*/
void mid_Order_Access(BTNode *head)
{
 BTNode *pt;
 ABTStack *ps,*top;
 int counter =1;
 pt = head;
 top = NULL;
 printf("/n二叉树的中序遍历结果<非递归>:/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: 二叉树的根节点指针  
*/
void last_Order_Access(BTNode *head)
{
 BTNode *pt;
 ABTStack *ps,*top;
 int counter =1;
 pt = head;
 top = NULL;
 printf("/n二叉树的后序遍历结果<非递归>:/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: 二叉查找树的根节点指针
  int key:  查找关键码
 返回值:
  static_Search_STree = 键值为key的节点指针(找到) 
  static_Search_STree = NULL(没有找到)
*/
BTNode *static_Search_STree(BTNode *head,int key)
{
 while(head!=NULL)
 {
  if(head->data == key)
  {
   printf("/n数据域=%d/t地址=%d/t/n",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(没有找到)
  int key:   查找关键码
 注意:
  *parent == NULL 且 *p == NULL 没有找到(二叉树为空)
  *parent == NULL 且 *p != NULL 找到(找到根节点)
  *parent != NULL 且 *p == NULL 没有找到(叶节点)<可在parent后插入节点>
  *parent != NULL 且 *p != NULL 找到(中间层节点)
*/
void dynamic_Search_STree(BTNode *head,BTNode **parent,BTNode **p,int key)
{
 *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: 二叉查找树的根节点指针
  int key:  查找关键码
 返回值:
  Insert_Node_STree = 1 插入成功
  Insert_Node_STree = 0 插入失败(节点已经存在)
*/
int Insert_Node_STree(BTNode *head,int key)
{
 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: 二叉查找树的根节点指针
  int array[]: 被插入的数据域数组
  int n:   被插入的节点数目
*/
void Insert_Batch_Node_STree(BTNode *head,int array[],int n)
{
 int i;
 for(i=0;i<n;i++)
 {
  if(!Insert_Node_STree(head,array[i]))
   printf("/n插入失败<键值为%d的节点已经存在>!/n",array[i]); 
 }
}
//------------------------------非递归部分------------------------------
 

 

二叉树(一):二叉树的创建以及三种遍历方法的递归实现

我们都知道现实生活中的树长什么样,那么,很明显,二叉树就是一棵“树”,不过它是一个存储数据的一种结构,根在上,向下生长。 当然,这样的存储结构只是其中的一种。在这里,就要引出二叉树的存储和二叉树的遍历...
  • qq_33951180
  • qq_33951180
  • 2016年09月27日 22:07
  • 1563

二叉树的创建即遍历(递归方式)

最近准备把数据结构书上的算法用代码实现一遍,在二叉树这块遇到了一点小问题,发现是自己指针这块还没过关,研究了一个小时候,终于明白二级指针的使用情况,(那些自认为自己指针过关的同学可不要停留在一级指针这...
  • u012997465
  • u012997465
  • 2016年04月06日 23:21
  • 1455

用递归方法对二叉树进行层次遍历

用递归方法对二叉树进行层次遍历       在这里看到了这个题。层次遍历是用队列,一级一级地入队列然后输出。而用递归的话,我首先想到是用两个栈来模拟队列,在递归遍历二叉树的过程中入栈,然后最...
  • jfkidear
  • jfkidear
  • 2016年10月24日 23:00
  • 1127

【数据结构与算法】二叉树递归与非递归遍历(附完整源码)

二叉树是一种非常重要的数据结构,很多其他数据机构都是基于二叉树的基础演变过来的。二叉树有前、中、后三种遍历方式,因为树的本身就是用递归定义的,因此采用递归的方法实现三种遍历,不仅代码简洁且容易理解,但...
  • mmc_maodun
  • mmc_maodun
  • 2013年10月24日 08:58
  • 40565

史上最简明易懂非递归遍历二叉树算法

三种不同的遍历方式区别在于栈空间的释放时机和输出结点信息时机的不同:先序和中序遍历是在访问栈顶元素的右孩子(右子树)之前退栈,而后序遍历在访问右子树之后退栈;先序遍历是在某结点入栈时输出其信息,而中序...
  • QiaoRuoZhuo
  • QiaoRuoZhuo
  • 2014年10月29日 14:59
  • 3710

二叉树几种遍历算法的非递归实现

二叉树遍历的非递归实现 相对于递归遍历二叉树,非递归遍历显得复杂了许多,但换来的好处是算法的时间效率有了提高。下面对于我学习非递归遍历二叉树算法的过程进行总结为了便于理解,这里以下图的二叉树为例,分析...
  • kelvinmao
  • kelvinmao
  • 2016年05月15日 11:43
  • 4510

数据结构-----中序遍历二叉树非递归算法(利用堆栈实现)

一、非递归中序遍历算法思想
  • u011459278
  • u011459278
  • 2014年04月19日 18:03
  • 3153

<数据结构>二叉树的递归、非递归以及层次遍历算法C语言实现

二叉树是数据结构中一种非常重要的结构,熟练的掌握二叉树的创建,遍历是打好编程基础的关键。对于遍历,不能仅仅只掌握递归遍历,还应掌握效率更高地非递归遍历。对于非递归的先序、中序、后序遍历要用到栈(在之前...
  • fzh1900
  • fzh1900
  • 2013年11月02日 17:12
  • 3587

二叉树的非递归遍历以及层次遍历(前序、中序、后序)

先使用先序的方法建立一棵二叉树,然后分别使用递归与非递归的方法实现前序、中序、后序遍历二叉树,并使用了两种方法来进行层次遍历二叉树,一种方法就是使用STL中的queue,另外一种方法就是定义了一个数组...
  • yusiguyuan
  • yusiguyuan
  • 2014年11月07日 21:11
  • 1647

对于二叉树三种非递归遍历方式的理解

利用栈实现二叉树的先序,中序,后序遍历的非递归操作 栈是一种先进后出的数据结构,其本质应是记录作用,支撑回溯(即按原路线返回);因此,基于其的二叉树遍历操作深刻的体现了其特性: 1.先入、后出,只...
  • sdulibh
  • sdulibh
  • 2016年01月24日 11:25
  • 1274
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:二叉树创建及遍历算法(递归及非递归)
举报原因:
原因补充:

(最多只允许输入30个字)