数据结构 设计性实验 广义表的抽象数据类型Word文档格式.docx

数据结构 设计性实验 广义表的抽象数据类型Word文档格式.docx

《数据结构 设计性实验 广义表的抽象数据类型Word文档格式.docx》由会员分享，可在线阅读，更多相关《数据结构 设计性实验 广义表的抽象数据类型Word文档格式.docx（23页珍藏版）》请在冰豆网上搜索。

反之，一对确定的表头和表尾可唯一确定列表。

由此，一个表结点可由三个域组成：

标志域、指示域和指示表尾的指针域；

而原子结点只需两个域：

标志域和值域（如图8所示）。

其形式定义说明如下：

存储结构:

公用头文件DS0.h:

#include<

string.h>

ctype.h>

malloc.h>

#include<

limits.h>

stdio.h>

#include<

stdlib.h>

io.h>

math.h>

process.h>

#defineTRUE1

#defineFALSE0#defineOK1

#defineERROR0#defineINFEASIBLE-1

typedefcharAtomType;

/*定义原子类型为字符型*/

//-----------广义表的头尾链表存储表示------------//

typedefenum{ATOM,LIST}ElemTag;

//

ATOM==0:

原子，LIST==1：

子表

typedefstructGLNode{

ElemTagtag;

//公共部分，用于区分原子结点和表结点

union{//原子结点和表结点的联合部分

AtomTypeatom;

//atom是原子结点的值域，AtomType由用户定义

Struct{structGLNode*hp,*tp;

}ptr;

//ptr是表结点的指针域，ptr.hp和ptr.tp分别指向表头和表尾

}；

}*Glist;

//广义表类型

//---------广义表的扩展线性链表存储表示----------//

//ATOM==0:

原子，LIST==1:

ElemTagtag;

union{//原子结点和表结点的联合部分

AtomTypeatom;

//原子结点的值域

StructGLNode*hp;

//表结点的表头指针

structGLNode*tp;

//相当于线性链表的next，指向下一个元素结点

}＊Glist;

//广义表类型Glist是一种扩展的线性链表

四,算法设计

#include<

#defineTRUE1

#defineFALSE0

#defineOK1

#defineERROR0

#defineINFEASIBLE-1

/*定义原子类型为字符型*/

typedefintStatus;

/*Status是函数的类型,其值是函数结果状态代码，如OK等*/

typedefintBoolean;

typedefstruct

{

char*ch;

/*若是非空串,则按串长分配存储区,否则ch为NULL*/

intlength;

/*串长度*/

}HString;

typedefenum{ATOM,LIST}ElemTag;

/*ATOM==0:

原子,LIST==1:

子表*/

typedefstructGLNode

ElemTagtag;

union

AtomTypeatom;

structGLNode*hp;

}a;

structGLNode*tp;

}*GList,GLNode;

StatusStrAssign（HString*T,char*chars）

{

inti,j;

if（（*T）.ch）

free（（*T）.ch）;

i=strlen（chars）;

if（!

i）

（*T）.ch=NULL;

（*T）.length=0;

}

else

{/*chars的长度不为0*/

（*T）.ch=（char*）malloc（i*sizeof（char））;

（*T）.ch）/*分配串空间失败*/

exit（OVERFLOW）;

for（j=0;

j<

i;

j++）/*拷贝串*/

（*T）.ch[j]=chars[j];

（*T）.length=i;

returnOK;

StatusStrCopy（HString*T,HStringS）

{/*初始条件:

串S存在。

操作结果:

由串S复制得串T*/

inti;

（*T）.ch=（char*）malloc（S.length*sizeof（char））;

（*T）.ch）

for（i=0;

i<

S.length;

i++）

（*T）.ch[i]=S.ch[i];

（*T）.length=S.length;

StatusStrEmpty（HStringS）

串S存在。

若S为空串,则返回TRUE,否则返回FALSE*/

if（S.length==0&

&

S.ch==NULL）

returnTRUE;

returnFALSE;

intStrCompare（HStringS,HStringT）

{/*若S>

T,则返回值>

0;

若S=T,则返回值=0;

若S<

T,则返回值<

0*/

S.length&

T.length;

++i）

if（S.ch[i]!

=T.ch[i]）

returnS.ch[i]-T.ch[i];

returnS.length-T.length;

intStrLength（HStringS）

{/*返回S的元素个数,称为串的长度*/

returnS.length;

StatusClearString（HString*S）

{/*将S清为空串*/

if（（*S）.ch）

free（（*S）.ch）;

（*S）.ch=NULL;

（*S）.length=0;

StatusConcat（HString*T,HStringS1,HStringS2）

{/*用T返回由S1和S2联接而成的新串*/

/*释放旧空间*/

（*T）.length=S1.length+S2.length;

（*T）.ch=（char*）malloc（（*T）.length*sizeof（char））;

（*T）.ch）

S1.length;

i++）

（*T）.ch[i]=S1.ch[i];

S2.length;

（*T）.ch[S1.length+i]=S2.ch[i];

StatusSubString（HString*Sub,HStringS,intpos,intlen）

{/*用Sub返回串S的第pos个字符起长度为len的子串。

*/

/*其中,1≤pos≤StrLength（S）且0≤len≤StrLength（S）-pos+1*/

if（pos<

1||pos>

S.length||len<

0||len>

S.length-pos+1）

returnERROR;

if（（*Sub）.ch）

free（（*Sub）.ch）;

len）/*空子串*/

（*Sub）.ch=NULL;

（*Sub）.length=0;

{/*完整子串*/

（*Sub）.ch=（char*）malloc（len*sizeof（char））;

（*Sub）.ch）

=len-1;

（*Sub）.ch[i]=S.ch[pos-1+i];

（*Sub）.length=len;

voidInitString（HString*T）

{/*初始化（产生空串）字符串T。

另加*/

intIndex（HStringS,HStringT,intpos）/*算法4.1*/

{/*T为非空串。

若主串S中第pos个字符之后存在与T相等的子串,*/

/*则返回第一个这样的子串在S中的位置,否则返回0*/

intn,m,i;

HStringsub;

InitString（&

sub）;

if（pos>

0）

n=StrLength（S）;

m=StrLength（T）;

i=pos;

while（i<

=n-m+1）

SubString（&

sub,S,i,m）;

if（StrCompare（sub,T）!

=0）

++i;

returni;

return0;

StatusStrInsert（HString*S,intpos,HStringT）/*算法4.4*/

{/*1≤pos≤StrLength（S）+1。

在串S的第pos个字符之前插入串T*/

（*S）.length+1）/*pos不合法*/

if（T.length）/*T非空,则重新分配空间,插入T*/

（*S）.ch=（char*）realloc（（*S）.ch,（（*S）.length+T.length）*sizeof（char））;

（*S）.ch）

for（i=（*S）.length-1;

i>

=pos-1;

--i）/*为插入T而腾出位置*/

（*S）.ch[i+T.length]=（*S）.ch[i];

（*S）.ch[pos-1+i]=T.ch[i];

/*插入T*/

（*S）.length+=T.length;

StatusStrDelete（HString*S,intpos,intlen）

{/*从串S中删除第pos个字符起长度为len的子串*/

if（（*S）.length<

pos+len-1）

exit（ERROR）;

for（i=pos-1;

=（*S）.length-len;

（*S）.ch[i]=（*S）.ch[i+len];

（*S）.length-=len;

（*S）.ch=（char*）realloc（（*S）.ch,（*S）.length*sizeof（char））;

StatusReplace（HString*S,HStringT,HStringV）

串S,T和V存在,T是非空串（此函数与串的存储结构无关）*/

/*操作结果:

用V替换主串S中出现的所有与T相等的不重叠的子串*/

inti=1;

/*从串S的第一个字符起查找串T*/

if（StrEmpty（T））/*T是空串*/

do

i=Index（*S,T,i）;

if（i）

StrDelete（S,i,StrLength（T））;

StrInsert（S,i,V）;

i+=StrLength（V）;

}while（i）;

voidDestroyString（）

{/*堆分配类型的字符串无法销毁*/

voidStrPrint（HStringT）

{/*输出T字符串。

printf（"

%c"

T.ch[i]）;

\n"

）;

/*广义表的书写形式串为HString类型*/

StatusInitGList（GList*L）

{/*创建空的广义表L*/

*L=NULL;

Statussever（HString*str,HString*hstr）/*同bo5-52.c*/

{/*将非空串str分割成两部分:

hstr为第一个'

'

之前的子串,str为之后的子串*/

intn,i=1,k=0;

/*k记尚未配对的左括号个数*/

HStringch,c1,c2,c3;

ch）;

/*初始化HString类型的变量*/

c1）;

c2）;

c3）;

StrAssign（&

c1,"

"

c2,"

（"

c3,"

）"

n=StrLength（*str）;

ch,*str,i,1）;

StrCompare（ch,c2））

++k;

elseif（!

StrCompare（ch,c3））

--k;

}while（i<

=n&

StrCompare（ch,c1）||k!

=0）;

if（i<

=n）

StrCopy（&

ch,*str）;

SubString（hstr,ch,1,i-2）;

SubString（str,ch,i,n-i+1）;

StrCopy（hstr,*str）;

ClearString（str）;

StatusCreateGList（GList*L,HStringS）

S是广义表的书写形式串。

由S创建广义表L*/

HStringemp,sub,hsub;

GListp;

emp）;

hsub）;

emp,"

（）"

/*设emp="

*L=（GList）malloc（sizeof（GLNode））;

*L）/*建表结点不成功*/

StrCompare（S,emp））/*创建空表*/

（*L）->

tag=LIST;

a.hp=NULL;

tp=NULL;

elseif（StrLength（S）==1）/*创建单原子广义表*/

tag=ATOM;

a.atom=S.ch[0];

else/*创建一般表*/

sub,S,2,StrLength（S）-2）;

/*脱外层括号*/

sever（&

sub,&

/*从sub中分离出表头串hsub*/

CreateGList（&

（*L）->

a.hp,hsub）;

p=（*L）->

a.hp;

while（!

StrEmpty（sub））/*表尾不空,则重复建n个子表*/

p->

tp,hsub）;

p=p->

tp;

};

voidDestroyGList（GList*L）

广义表L存在。

销毁广义表L*/

GListph,pt;

if（*L）/*L不为空表*/

{/*由ph和pt接替L的两个指针*/

if（（*L）->

tag）/*是子表*/

ph=（*L）->

else/*是原子*/

ph=NULL;

pt=（*L）->

free（*L）;

/*释放L所指结点*/

/*令L为空*/

DestroyGList（&

ph）;

/*递归销毁表ph*/

pt）;

/*递归销毁表pt*/

StatusCopyGList（GList*T,GListL）

由广义表L复制得到广义表T*/

L）/*L空*/

*T=NULL;

*T=（GList）malloc（sizeof（GLNode））;

*T）

（*T）->

tag=L->

tag;

/*复制枚举变量*/

if（L->

tag==ATOM）/*复制共用体部分*/

a.atom=L->

a.atom;

/*复制单原子*/

CopyGList（&

（*T）->

a.hp,L->

a.hp）;

/*复制子表*/

tp==NULL）/*到表尾*/

tp=L->

tp,L->

tp）;

intGListLength（GListL）

求广义表L的长度,即元素个数*/

intlen=0;

tag==LIST&

!

L->

a.hp）/*空表*/

/*空表返回0*/

elseif（L->

tag==ATOM）/*单原子表*/

return1;

else/*一般表*/

p=L->

len++;

}while（p）;

returnlen;

intGListDepth（GListL）

求广义表L的深度*/

intmax,dep;

GListpp;

if（L==NULL||L->

a.hp）

/*空表深度为1*/

tag==ATOM）

/*单原子表深度为0*/

else/*求一般表的深度*/

for（max=0,pp=L->

pp;

pp=pp->

tp）

dep=GListDepth（pp）;

/*求以pp为头指针的子表深度*/

if（dep>

max）

max=dep;

returnmax+1;

/*非空表的深度是各元素的深度的最大值加1*/

StatusGListEmpty（GListL）

判定广义表L是否为空*/

L||L->

GListGetHead（GListL）

取广义表L的头*/

GListh;

InitGList（&

h）;

L-