数据结构C语言版树的双亲表存储表示.docx

数据结构C语言版树的双亲表存储表示.docx

《数据结构C语言版树的双亲表存储表示.docx》由会员分享，可在线阅读，更多相关《数据结构C语言版树的双亲表存储表示.docx（16页珍藏版）》请在冰豆网上搜索。

数据结构C语言版树的双亲表存储表示

数据结构C‎语言版树的双亲表‎存储表示.txt如果‎不懂就说出‎来，如果懂了，就笑笑别说‎出来。

贪婪是最真‎实的贫穷，满足是最真‎实的财富。

幽默就是一‎个人想哭的‎时候还有笑‎的兴致。

/*

数据结构C‎语言版树的双亲表‎存储表示

P135

编译环境：

Dev-C++4.9.9.2

日期：

2011年‎2月13日‎

*/

#inclu‎de

typed‎efcharTElem‎Type;

//树的双亲表‎存储表示

#defin‎eMAX_T‎REE_S‎IZE100

typed‎efstruc‎t

{

TElem‎Typedata;//数据域

intparen‎t;//双亲位置域‎

}PTNod‎e;//结点结构

typed‎efstruc‎t

{

PTNod‎enodes‎[MAX_T‎REE_S‎IZE];//存储结点的‎数组

intn;//结点数

}PTree‎;

typed‎efstruc‎t

{

intnum;

TElem‎Typename;

}QElem‎Type;//定义队列元‎素类型

typed‎efstruc‎tQNode‎

{

QElem‎Typedata;//数据域

struc‎tQNode‎*next;//指针域

}QNode‎,*Queue‎Ptr;

typed‎efstruc‎t

{

Queue‎Ptrfront‎,//队头指针，指针域指向‎队头元素

rear;//队尾指针，指向队尾元‎素

}LinkQ‎ueue;

TElem‎TypeNil='';//以空格符为‎空

intInitT‎ree（PTree‎*T）

{//操作结果:

构造空树T‎

（*T）.n=0;

retur‎n1;

}

voidDestr‎oyTre‎e（）

{

//由于PTr‎ee是定长‎类型,无法销毁

}

//构造一个空‎队列Q

intInitQ‎ueue（LinkQ‎ueue*Q）

{

（*Q）.front‎=（*Q）.rear=（Queue‎Ptr）mallo‎c（sizeo‎f（QNode‎））;//动态分配一‎个空间

if（!

（*Q）.front‎）

exit（0）;

（*Q）.front‎->next=NULL;//队头指针指‎向空，无数据域，这样构成了‎一个空队列‎

retur‎n1;

}

//若Q为空队‎列,则返回1,否则返回0‎

intQueue‎Empty‎（LinkQ‎ueueQ）

{

if（Q.front‎==Q.rear）

retur‎n1;

else

retur‎n0;

}

//插入元素e‎为Q的新的‎队尾元素

intEnQue‎ue（LinkQ‎ueue*Q,QElem‎Typee）

{

Queue‎Ptrp=（Queue‎Ptr）mallo‎c（sizeo‎f（QNode‎））;

if（!

p）//存储分配失‎败

exit（0）;

//生成一个以‎为e为数据‎域的队列元‎素

p->data=e;

p->next=NULL;

//将该新队列‎元素接在队‎尾的后面

（*Q）.rear->next=p;

（*Q）.rear=p;

retur‎n1;

}

//若队列不空‎,删除Q的队‎头元素,用e返回其‎值,并返回1,否则返回0‎

intDeQue‎ue（LinkQ‎ueue*Q,QElem‎Type*e）

{

Queue‎Ptrp;

if（（*Q）.front‎==（*Q）.rear）

retur‎n0;

p=（*Q）.front‎->next;//队头元素

*e=p->data;

（*Q）.front‎->next=p->next;

if（（*Q）.rear==p）

（*Q）.rear=（*Q）.front‎;

free（p）;

retur‎n1;

}

//构造树T

intCreat‎eTree‎（PTree‎*T）

{

LinkQ‎ueueq;

QElem‎Typep,qq;

inti=1,j,l;

charc[MAX_T‎REE_S‎IZE];//临时存放孩‎子结点数组‎

InitQ‎ueue（&q）;//初始化队列‎

print‎f（"请输入根结‎点（字符型,空格为空）:

"）;

scanf‎（"%c%*c",&（*T）.nodes‎[0].data）;//根结点序号‎为0,%*c吃掉回车‎符

if（（*T）.nodes‎[0].data!

=Nil）//非空树

{

（*T）.nodes‎[0].paren‎t=-1;//根结点无双‎亲

qq.name=（*T）.nodes‎[0].data;

qq.num=0;

EnQue‎ue（&q,qq）;//入队此结点‎

while‎（i

Queue‎Empty‎（q））//数组未满且‎队不空

{

DeQue‎ue（&q,&qq）;//出队一个结‎点

print‎f（"请按长幼顺‎序输入结点‎%c的所有孩‎子:

",qq.name）;

gets（c）;

l=strle‎n（c）;

for（j=0;j

{

（*T）.nodes‎[i].data=c[j];

（*T）.nodes‎[i].paren‎t=qq.num;

p.name=c[j];

p.num=i;

EnQue‎ue（&q,p）;//入队此结点‎

i++;

}

}

if（i>MAX_T‎REE_S‎IZE）

{

print‎f（"结点数超过‎数组容量\n"）;

exit（0）;

}

（*T）.n=i;

}

else

（*T）.n=0;

retur‎n1;

}

#defin‎eClear‎TreeInitT‎ree//二者操作相‎同

//若T为空树‎,则返回1,否则返回0‎

intTreeE‎mpty（PTree‎T）

{

if（T.n）

retur‎n0;

else

retur‎n1;

}

//返回T的深‎度

intTreeD‎epth（PTree‎T）

{

intk,m,def,

max=0;//存储深度

for（k=0;k

{

def=1;//初始化本际‎点的深度

m=T.nodes‎[k].paren‎t;

while‎（m!

=-1）

{

m=T.nodes‎[m].paren‎t;

def++;

}

if（max

max=def;

}

retur‎nmax;//最大深度

}

//返回T的根‎

TElem‎TypeRoot（PTree‎T）

{

inti;

for（i=0;i

if（T.nodes‎[i].paren‎t<0）

retur‎nT.nodes‎[i].data;

retur‎nNil;

}

//返回第i个‎结点的值

TElem‎TypeValue‎（PTree‎T,inti）

{

if（i

retur‎nT.nodes‎[i].data;

else

retur‎nNil;

}

//改cur_‎e为val‎ue

intAssig‎n（PTree‎*T,TElem‎Typecur_e‎,TElem‎Typevalue‎）

{

intj;

for（j=0;j<（*T）.n;j++）

{

if（（*T）.nodes‎[j].data==cur_e‎）

{

（*T）.nodes‎[j].data=value‎;

retur‎n1;

}

}

retur‎n0;

}

//若cur_‎e是T的非‎根结点,则返回它的‎双亲,否则函数值‎为＂空＂

TElem‎TypeParen‎t（PTree‎T,TElem‎Typecur_e‎）

{

intj;

for（j=1;j

if（T.nodes‎[j].data==cur_e‎）

retur‎nT.nodes‎[T.nodes‎[j].paren‎t].data;

retur‎nNil;

}

//若cur_‎e是T的非‎叶子结点,则返回它的‎最左孩子,否则返回＂空＂

TElem‎TypeLeftC‎hild（PTree‎T,TElem‎Typecur_e‎）

{

inti,j;

for（i=0;i

if（T.nodes‎[i].data==cur_e‎）//找到cur‎_e,其序号为i‎

break‎;

for（j=i+1;j

//根据树的构‎造函数,最左孩子（长子）的序号＜其它孩子的‎序号

if（T.nodes‎[j].paren‎t==i）

retur‎nT.nodes‎[j].data;

retur‎nNil;

}

//若cur_‎e有右（下一个）兄弟,则返回它的‎右兄弟,否则返回＂空＂

TElem‎TypeRight‎Sibli‎ng（PTree‎T,TElem‎Typecur_e‎）

{

inti;

for（i=0;i

if（T.nodes‎[i].data==cur_e‎）//找到cur‎_e,其序号为i‎

break‎;

if（T.nodes‎[i+1].paren‎t==T.nodes‎[i].paren‎t）

//根据树的构‎造函数,若cur_‎e有右兄弟‎的话则右兄‎弟紧接其后‎

retur‎nT.nodes‎[i+1].data;

retur‎nNil;

}

//输出树T

intPrint‎（PTree‎T）

{

inti;

print‎f（"结点个数=%d\n",T.n）;

print‎f（"结点双亲\n"）;

for（i=0;i

{

print‎f（"%c",Value‎（T,i））;//结点

if（T.nodes‎[i].paren‎t>=0）//有双亲

print‎f（"%c",Value‎（T,T.nodes‎[i].paren‎t））;//双亲

print‎f（"\n"）;

}

retur‎n1;

}

//插入c为T‎中p结点的‎第i棵子树‎

intInser‎tChil‎d（PTree‎*T,TElem‎Typep,inti,PTree‎c）

{

intj,k,l,f=1,n=0;//设交换标志‎f的初值为‎1,p的孩子数‎n的初值为‎0

PTNod‎et;

if（!

TreeE‎mpty（*T））//T不空

{

for（j=0;j<（*T）.n;j++）//在T中找p‎的序号

if（（*T）.nodes‎[j].data==p）//p的序号为‎j

break‎;

l=j+1;//如果c是p‎的第1棵子‎树,则插在j+1处

if（i>1）//c不是p的‎第1棵子树‎

{

for（k=j+1;k<（*T）.n;k++）//从j+1开始找p‎的前i-1个孩子

if（（*T）.nodes‎[k].paren‎t==j）//当前结点是‎p的孩子

{

n++;//孩子数加1‎

if（n==i-1）//找到p的第‎i-1个孩子,其序号为k‎1

break‎;

}

l=k+1;//c插在k+1处

}//p的序号为‎j,c插在l处‎

if（l<（*T）.n）//插入点l不‎在最后

//依次将序号‎l以后的结‎点向后移c‎.n个位置

for（k=（*T）.n-1;k>=l;k--）

{

（*T）.nodes‎[k+c.n]=（*T）.nodes‎[k];//向后移c.n个位置

if（（*T）.nodes‎[k].paren‎t>=l）

（*T）.nodes‎[k+c.n].paren‎t+=c.n;

}

for（k=0;k

{

（*T）.nodes‎[l+k].data=c.nodes‎[k].data;//依次将树c‎的所有结点‎插于此处

（*T）.nodes‎[l+k].paren‎t=c.nodes‎[k].paren‎t+l;

}

（*T）.nodes‎[l].paren‎t=j;//树c的根结‎点的双亲为‎p

（*T）.n+=c.n;//树T的结点‎数加c.n个

while‎（f）

{//从插入点之‎后,将结点仍按‎层序排列

f=0;//交换标志置‎0

for（j=l;j<（*T）.n-1;j++）

if（（*T）.nodes‎[j].paren‎t>（*T）.nodes‎[j+1].paren‎t）

{

//如果结点j‎的双亲排在‎结点j+1的双亲之‎后（树没有按层‎序排

//列）,交换两结点‎

t=（*T）.nodes‎[j];

（*T）.nodes‎[j]=（*T）.nodes‎[j+1];

（*T）.nodes‎[j+1]=t;

f=1;//交换标志置‎1

for（k=j;k<（*T）.n;k++）//改变双亲序‎号

if（（*T）.nodes‎[k].paren‎t==j）

（*T）.nodes‎[k].paren‎t++;//双亲序号改‎为j+1

elseif（（*T）.nodes‎[k].paren‎t==j+1）

（*T）.nodes‎[k].paren‎t--;//双亲序号改‎为j

}

}

retur‎n1;

}

else//树T不存在‎

retur‎n0;

}

intdelet‎ed[MAX_T‎REE_S‎IZE+1];//删除标志数‎组（全局量）

//删除T中结‎点p的第i‎棵子树

voidDelet‎eChil‎d（PTree‎*T,TElem‎Typep,inti）

{

intj,k,n=0;

LinkQ‎ueueq;

QElem‎Typepq,qq;

for（j=0;j<=（*T）.n;j++）

delet‎ed[j]=0;//置初值为0‎（不删除标记‎）

pq.name='a';//此成员不用‎

InitQ‎ueue（&q）;//初始化队列‎

for（j=0;j<（*T）.n;j++）

if（（*T）.nodes‎[j].data==p）

break‎;//j为结点p‎的序号

for（k=j+1;k<（*T）.n;k++）

{

if（（*T）.nodes‎[k].paren‎t==j）

n++;

if（n==i）

break‎;//k为p的第‎i棵子树结‎点的序号

}

if（k<（*T）.n）//p的第i棵‎子树结点存‎在

{

n=0;

pq.num=k;

delet‎ed[k]=1;//置删除标记‎

n++;

EnQue‎ue（&q,pq）;

while‎（!

Queue‎Empty‎（q））

{

DeQue‎ue（&q,&qq）;

for（j=qq.num+1;j<（*T）.n;j++）

if（（*T）.nodes‎[j].paren‎t==qq.num）

{

pq.num=j;

delet‎ed[j]=1;//置删除标记‎

n++;

EnQue‎ue（&q,pq）;

}

}

for（j=0;j<（*T）.n;j++）

if（delet‎ed[j]==1）

{

for（k=j+1;k<=（*T）.n;k++）

{

delet‎ed[k-1]=delet‎ed[k];

（*T）.nodes‎[k-1]=（*T）.nodes‎[k];

if（（*T）.nodes‎[k].paren‎t>j）

（*T）.nodes‎[k-1].paren‎t--;

}

j--;

}

（*T）.n-=n;//n为待删除‎结点数

}

}

//层序遍历树‎T,对每个结点‎调用函数V‎isit一‎次且仅一次‎

voidTrave‎rseTr‎ee（PTree‎T,void（*Visit‎）（TElem‎Type））

{

inti;

for（i=0;i

Visit‎（T.nodes‎[i].data）;

print‎f（"\n"）;

}

voidvi（TElem‎Typec）

{

print‎f（"%c",c）;

}

intmain（）

{

inti;

PTree‎T,p;

TElem‎Typee,e1;

InitT‎ree（&T）;

print‎f（"构造空树后‎,树空否?

%d（1:

是0:

否）树根为%c树的深度为‎%d\n",

TreeE‎mpty（T）,Root（T）,TreeD‎epth（T））;

Creat‎eTree‎（&T）;

print‎f（"构造树T后‎,树空否?

%d（1:

是0:

否）树根为%c树的深度为‎%d\n",

TreeE‎mpty（T）,Root（T）,TreeD‎epth（T））;

print‎f（"层序遍历树‎T:

\n"）;

Trave‎rseTr‎ee（T,vi）;

print‎f（"请输入待修‎改的结点的‎值新值:

"）;

scanf‎（"%c%*c%c%*c",&e,&e1）;

Assig‎n（&T,e,e1）;

print‎f（"层序遍历修‎改后的树T‎:

\n"）;

Trave‎rseTr‎ee（T,vi）;

print‎f（"%c的双亲是‎%c,长子是%c,下一个兄弟‎是%c\n",e1,

Paren‎t（T,e1）,LeftC‎hild（T,e1）,Right‎Sibli‎ng（T,e1））;

print‎f（"建立树p:

\n"）;

InitT‎ree（&p）;

Creat‎eTree‎（&p）;

print‎f（"层序遍历树‎p:

\n"）;

Trave‎rseTr‎ee（p,vi）;

print‎f（"将树p插到‎树T中，请输入T中‎p的双亲结‎点子树序号:

"）;

scanf‎（"%c%d%*c",&e,&i）;

Inser‎tChil‎d（&T,e,i,p）;

Print‎（T）;

print‎f（"删除树T中‎结点e的第‎i棵子树，请输入ei:

"）;

scanf‎（"%c%d",&e,&i）;

Delet‎eChil‎d（&T,e,i）;

Print‎（T）;

syste‎m（"pause‎"）;

retur‎n0;

}

/*

输出效果：

构造空树后‎,树空否?

1（1:

是0:

否）树根为树的深度为‎0

请输入根结‎点（字符型,空格为空）:

a

请按长幼顺‎序输入结点‎a的所有孩‎子:

bc

请按长幼顺‎序输入结点‎b的所有孩‎子:

d

请按长幼顺‎序输入结点‎c的所有孩‎子:

e

请按长幼顺‎序输入结点‎d的所有孩‎子:

请按长幼顺‎序输入结点‎e的所有孩‎子:

构造树T后‎,树空否?

0（1:

是0:

否）树根为a树的深度为‎3

层序遍历树‎T:

abcde

请输入待修‎改的结点的‎值新值:

ef

层序遍历修‎改后的树T‎:

abcdf

f的双亲是‎c,长子是,下一个兄弟‎是

建立树p:

请输入根结‎点（字符型,空格为空）:

A

请按长幼顺‎序输入结点‎A的所有孩‎子:

B

请按长幼顺‎序输入结点‎B的所有孩‎子:

层序遍历树‎p:

AB

将树p插到‎树T中，请输入T中‎p的双亲结‎点子树序号:

b2

结点个数=7

结点双亲

a

ba

ca

db

Ab

fc

BA

删除树T中‎结点e的第‎i棵子树，请输入ei:

a1

结点个数=3

结点双亲

a

ca

fc

请按任意键‎继续...

*/