数据结构--广义表
Code：
#include<string.h>
#include<ctype.h>
#include<malloc.h>
#include<limits.h>
#include<stdio.h>
#include<stdlib.h>
#include<io.h>
#include<math.h>
#include<process.h> //exit()
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
typedef char AtomType; //定义原子类型为字符型
typedef int Status; //Status是函数的类型，其值是函数结果状态代码，如OK等
/* 串的堆分配存储表示*/
typedef struct
{
char *ch; //若是非空串,则按串长分配存储区,否则ch为NULL
int length; //串长度
}HString;
/* 广义表的扩展线性链表存储表示*/
typedef enum{ATOM,LIST}ElemTag; //ATOM==0:原子,LIST==1:子表
typedef struct GLNode
{
ElemTag tag; //公共部分，用于区分原子结点和表结点
union //原子结点和表结点的联合部分
{
AtomType atom; //原子结点的值域，AtomType自定义为字符型
struct GLNode *hp; //表结点的表头指针
}a;
struct GLNode *tp; //相当于线性链表的next，指向下一个元素结点
}*GList,GLNode; //广义表类型GList是一种扩展的线性链表
//1. 创建串
Status StrAssign(HString *T,char *chars)
{
int i,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));
if(!(*T).ch) //分配串空间失败
exit(OVERFLOW);
for(j=0;j<i;j++) //拷贝串
(*T).ch[j]=chars[j];
(*T).length=i;
}
return OK;
}
//2. 串拷贝：由串S复制得串T
Status StrCopy(HString *T,HString S)
{
int i;
if((*T).ch)
free((*T).ch);
(*T).ch=(char*)malloc(S.length*sizeof(char));
if(!(*T).ch)
exit(OVERFLOW);
for(i=0;i<S.length;i++)
(*T).ch[i]=S.ch[i];
(*T).length=S.length;
return OK;
}
//3. 判断串是否为空：若S为空串,则返回TRUE,否则返回FALSE
Status StrEmpty(HString S)
{
if(S.length==0&&S.ch==NULL)
return TRUE;
else
return FALSE;
}
//4. 比较串长：若S>T,则返回值>0;若S=T,则返回值=0;若S<T,则返回值<0
int StrCompare(HString S,HString T)
{
int i;
for(i=0;i<S.length&&i<T.length;++i)
if(S.ch[i]!=T.ch[i])
return S.ch[i]-T.ch[i];
return S.length-T.length;
}
//5. 取串长：返回S的元素个数,称为串的长度
int StrLength(HString S)
{
return S.length;
}
//6. 清空串：将S清为空串
Status ClearString(HString *S)
{
if((*S).ch)
{
free((*S).ch);
(*S).ch=NULL;
}
(*S).length=0;
return OK;
}
//7. 取子串：用Sub返回串S的第pos个字符起长度为len的子串
Status SubString(HString *Sub, HString S,int pos,int len)
{ //其中,1≤pos≤StrLength(S)且0≤len≤StrLength(S)-pos+1
int i;
if(pos<1||pos>S.length||len<0||len>S.length-pos+1)
return ERROR;
if((*Sub).ch)
free((*Sub).ch); //释放旧空间
if(!len) //空子串
{
(*Sub).ch=NULL;
(*Sub).length=0;
}
else
{ //完整子串
(*Sub).ch=(char*)malloc(len*sizeof(char));
if(!(*Sub).ch)
exit(OVERFLOW);
for(i=0;i<=len-1;i++)
(*Sub).ch[i]=S.ch[pos-1+i];
(*Sub).length=len;
}
return OK;
}
//8. 初始化串：初始化(产生空串)字符串T
void InitString(HString *T)
{
(*T).length=0;
(*T).ch=NULL;
}
//9. 分割串：将非空串str分割成两部分:hstr为第一个','之前的子串,str为之后的子串
Status sever(HString *str,HString *hstr)
{
int n,i=1,k=0; //k记尚未配对的左括号个数
HString ch,c1,c2,c3;
InitString(&ch); //初始化HString类型的变量
InitString(&c1);
InitString(&c2);
InitString(&c3);
StrAssign(&c1,","); //调用创建串函数
StrAssign(&c2,"(");
StrAssign(&c3,")");
n=StrLength(*str); //调用取串长函数
do
{
SubString(&ch,*str,i,1); //取子串
if(!StrCompare(ch,c2)) //调用比较串长函数
++k;
else if(!StrCompare(ch,c3)) //调用比较串长函数
--k;
++i;
}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); //取子串
}
else
{
StrCopy(hstr,*str); //调用串拷贝函数
ClearString(str); //清空串str
}
return OK;
}
//10. 创建空的广义表L
Status InitGList(GList *L)
{
*L=NULL;
return OK;
}
//11. 由串S创建广义表L：初始条件为S是广义表的书写形式串
Status CreateGList(GList *L,HString S)
{
HString emp,sub,hsub;
GList p;
InitString(&emp); //初始化HString类型的变量
InitString(&sub);
InitString(&hsub);
StrAssign(&emp,"()"); //调用创建串函数，设emp="()"
*L=(GList)malloc(sizeof(GLNode));
if(!*L) //建表结点不成功
exit(OVERFLOW);
if(!StrCompare(S,emp)) //调用比较串长函数判断若S与emp的串长不相等, 则创建空表
{
(*L)->tag=LIST;
(*L)->a.hp=NULL;
(*L)->tp=NULL;
}
else if(StrLength(S)==1) //若S的串长为1，则创建单原子广义表
{
(*L)->tag=ATOM;
(*L)->a.atom=S.ch[0];
(*L)->tp=NULL;
}
else //创建一般表
{
(*L)->tag=LIST;
(*L)->tp=NULL;
SubString(&sub,S,2,StrLength(S)-2); //脱外层括号
sever(&sub,&hsub); //从sub中分离出表头串hsub
CreateGList(&(*L)->a.hp,hsub); //递归创建广义表L
p=(*L)->a.hp;
while(!StrEmpty(sub)) //调用StrEmpty函数判断表尾是否为空。若否，则重复建n个子表
{
sever(&sub,&hsub); //从sub中分离出表头串hsub
CreateGList(&p->tp,hsub);
p=p->tp;
}
}
return OK;
}
//12. 销毁广义表L
void DestroyGList(GList *L)
{
GList ph,pt;
if(*L) //L不为空表
{ //由ph和pt接替L的两个指针
if((*L)->tag) //是子表
ph=(*L)->a.hp;
else //是原子
ph=NULL;
pt=(*L)->tp;
free(*L); //释放L所指结点
*L=NULL; //令L为空
DestroyGList(&ph); //递归销毁表ph
DestroyGList(&pt); //递归销毁表pt
}
}
//13. 广义表拷贝：由广义表L复制得到广义表T
Status CopyGList(GList *T,GList L)
{
if(!L) //L空
{
*T=NULL;
return OK;
}
*T=(GList)malloc(sizeof(GLNode));
if(!*T)
exit(OVERFLOW);
(*T)->tag=L->tag; //复制枚举变量
if(L->tag==ATOM) //复制共用体部分
(*T)->a.atom=L->a.atom; //复制单原子
else
CopyGList(&(*T)->a.hp,L->a.hp); //函数递归的调用，复制子表
if(L->tp==NULL) //到表尾
(*T)->tp=L->tp;
else
CopyGList(&(*T)->tp,L->tp); //复制子表
return OK;
}
//14. 求广义表L的长度,即元素个数
int GListLength(GList L)
{
int len=0;
GList p;
if(L->tag==LIST&&!L->a.hp) //空表
return 0; //空表返回0
else if(L->tag==ATOM) //单原子表
return 1;
else //一般表
{
p=L->a.hp;
do
{
len++;
p=p->tp;
}while(p);
return len;
}
}
//15. 求广义表L的深度
int GListDepth(GList L)
{
int max,dep;
GList pp;
if(L==NULL||L->tag==LIST&&!L->a.hp)
return 1; //空表深度为1
else if(L->tag==ATOM)
return 0; //单原子表深度为0
else //求一般表的深度
for(max=0,pp=L->a.hp;pp;pp=pp->tp)
{
dep=GListDepth(pp); //递归求以pp为头指针的子表深度
if(dep>max)
max=dep;
}
return max+1; //非空表的深度是各元素的深度的最大值加1
}
//16. 取广义表L的头
GList GetHead(GList L)
{
GList h;
InitGList(&h); // 创建空广义表h
if ( !L || L->tag==LIST && !L->a.hp) // 若L为空表
{
printf ( "\n空表无表头!"); // 输出提示
exit ( 0); // 若表空, 则退出
}
h=(GList)malloc(sizeof(GLNode)); // 为广义表h动态分配内存空间
if ( !h) // 分配空间失败, 退出
exit ( OVERFLOW);
h->tag=L->a.hp->tag; // 取表头
h->tp=NULL;
if ( h->tag==ATOM) // 表头为单原子
h->a.atom=L->a.hp->a.atom;
else // 表头为子表
CopyGList(&h->a.hp,L->a.hp->a.hp);
return h; // 返回表头
}
//17. 取广义表L的尾
GList GetTail(GList L)
{
GList T; // 声明广义表类型变量T
if ( !L) // 若L为空表
{
printf ( "\n空表无表尾!"); // 输出提示
exit ( 0); // 退出
}
T=(GList)malloc(sizeof(GLNode)); // 为广义表T动态分配内存空间
if ( !T) // 分配空间失败, 退出
exit ( OVERFLOW);
T->tag=LIST; // 表尾一定是子表, 省去判断
T->tp=NULL;
CopyGList(&T->a.hp,L->a.hp->tp); // 调用复制广义表函数将表尾赋值给T
return T; // 返回表尾
}
//18. 利用递归算法遍历广义表L
void Traverse_GL(GList L,void(*v)(AtomType))
{
GList hp;
if(L) //L不空
{
if(L->tag==ATOM) //L为单原子
{
v(L->a.atom);
hp=NULL;
}
else //L为子表
hp=L->a.hp;
Traverse_GL(hp,v); //递归调用
Traverse_GL(L->tp,v);
}
}
//19. 访问函数，将作为Traverse_GL函数的实参
void visit(AtomType e)
{
printf("%c ", e);
}
//20. 主函数
void main( )
{
char p[80];
int i;
GList l,m;
HString t;
InitString(&t); // 初始化HString类型的变量
InitGList(&l); // 创建空广义表
InitGList(&m);
do
{
printf ( "\n***************************************\n");
printf ( "\t请输入你选择的操作:\n");
printf ( "\t1、 创建广义表L\n");
printf ( "\t2、 求广义表L的长度\n");
printf ( "\t3、 求广义表L的深度\n");
printf ( "\t4、 利用递归算法遍历广义表L\n");
printf ( "\t5、 复制广义表L至广义表M\n");
printf ( "\t6、 求广义表M的长度\n");
printf ( "\t7、 求广义表M的深度\n");
printf ( "\t8、 利用非递归算法遍历广义表M\n");
printf ( "\t9、 求广义表L的表头，并遍历\n");
printf ( "\t10、求广义表L的表尾，并遍历\n");
printf ( "\t0、 退出\n");
printf ( "***************************************\n");
do
{
printf ( "输入(0-10)：");
scanf ( "%d",&i); getchar ( );
}while ( i<0||i>10);
switch(i){
case 1:
printf("请输入广义表L【如(a,(b),b))】：");
gets(p);
StrAssign(&t,p);
printf("广义表L为：%s\n",t);
CreateGList(&l,t); // 由t创建广义表l
break;
case 2:
printf ( "广义表L的长度=%d\n",GListLength(l)); // 调用取广义表长度函数
break;
case 3:
printf ( "广义表L的深度=%d \n",GListDepth(l)); // 调用取广义表深度函数
break;
case 4:
printf ( "利用递归算法遍历广义表L：\n");
Traverse_GL(l,visit); // 调用访问函数，处理l的每个元素
printf ( "\n");
break;
case 5:
CopyGList(&m,l);
printf ( "已复制广义表L至广义表M，广义表M为：%s\n",t);
break;
case 6:
printf ( "广义表M的长度=%d\n",GListLength(m)); // 调用取广义表长度函数
break;
case 7:
printf ( "广义表M的深度=%d\n",GListDepth(m)); // 调用取广义表深度函数
break;
case 8:
printf ( "利用非递归算法遍历广义表M：\n");
Traverse_GL(m,visit); // 调用访问函数，处理m的每个元素
printf ( "\n");
break;
case 9:
DestroyGList(&m); // 销毁广义表m
m=GetHead(l); // 取广义表l的头
printf ( "求广义表L的表头，并遍历：\n");
Traverse_GL(m,visit); // 遍历广义表m
printf ( "\n");
break;
case 10:
DestroyGList(&m); // 销毁广义表m
m=GetTail(l); // 取广义表l的尾
printf ( "m求广义表L的表尾，并遍历：\n");
Traverse_GL(m,visit); // 遍历广义表m
printf ( "\n");
}
}while ( i);
printf ( "\n");
DestroyGList(&m); // 销毁广义表m
system("PAUSE"); // 屏幕暂停
}