数据结构二叉树处理.docx
- 文档编号:2527548
- 上传时间:2023-05-03
- 格式:DOCX
- 页数:16
- 大小:17.58KB
数据结构二叉树处理.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]); } } //------------------------------非递归部分------------------------------
- 配套讲稿:
如PPT文件的首页显示word图标,表示该PPT已包含配套word讲稿。双击word图标可打开word文档。
- 特殊限制:
部分文档作品中含有的国旗、国徽等图片,仅作为作品整体效果示例展示,禁止商用。设计者仅对作品中独创性部分享有著作权。
- 关 键 词:
- 数据结构 二叉 处理