数据结构广义表的运算.docx

数据结构广义表的运算.docx

《数据结构广义表的运算.docx》由会员分享，可在线阅读，更多相关《数据结构广义表的运算.docx（13页珍藏版）》请在冰豆网上搜索。

数据结构广义表的运算

《数据结构》课程设计

题目：

广义表的运算

广义表是线性表的推广。

线性表的元素仅限于原子项。

广义表的元素或者是原子，或者是一个广义表，有其自身结构。

广义表通常用圆括号括起来，用逗号分隔其中的元素。

为了区分原子和广义表，书写时用大写字母表示广义表，用小写字母表示原子。

LS=（a1,a2,…,an）,LS是广义表的名字，n为它的长度，若ai是广义表，则称它为LS的子表。

若广义表非空（n>=1），则a1是LS的表头，其余元素组成的表（a2,…,an）称为LS的表尾。

一个表展开后所含括号的层数称为广义表的深度。

本设计要求实现广义表的建立、查找、输出、取表头、取表尾及求深度等运算。

选择合适的存储结构表示广义表，并能实现下列运算要求：

（1）用大写字母表示广义表，用小写字母表示原子，并提供设置广义表的值的功能。

（2）取广义表L的表头和表尾的函数head（L）和tail（L）。

（3）能用这两个函数的复合形式求出广义表中的指定元素。

（4）由广义表的字符串形式到广义表的转换函数ListsStr_ToLists_（S）；例如Str_ToLists_（“（a,（a,b）,c）”）的值为一个广义表。

（5）由广义表到广义表的字符串形式的转换函数char*Lists_To_Str（L）。

（6）最好能设置多个广义表。

解：

本题的解法如下：

1算法设计

1.由于广义表（a1,a2,…,an）中的数据元素可以具有不同的结构（或是原子或是列表）因此难以用顺序存储结构表示，通常采取链式存储结构，每个元素都可以用一个结点表示。

一个表结点可由3个域组成：

标志域，指针表头的指针域和指针表尾的指针域；而原子结点只需两个域：

标志域和值域。

2.假设以字符串L=（a1,a2,…,an）的形式定义广义表L，建立相应的存储结构。

对广义表进行的操作下递归定义时，可以有两种方法。

一种是把广义表分解成表头和表尾两部分；另一种是把广义表堪称含有n个并列子表（假设原子也视作子表）的表。

在讨论建立广义表的存储结构时，这两种分析方法均可。

3.实现查找，即实现广义表的遍历。

4.取表头和表尾：

广义表一般记做LS=（α1，α2，…αn）其中，LS是广义表LS=（α1，α2，…αn）的名称，n是它的长度。

在线性表的定义中，αi（1<=i<=n）只限于单个元素，而在广义表的定义中，αi可以是单个元素，也可以是广义表，分别称为广义表LS的原子和子表。

当广义表非空时，称第一个元素αi为LS的表头，称其余的元素组成的表（α2，α3，…αn）为LS的表尾。

5.由广义表的字符串形式到广义表转换函数：

由于S中的每个子串αi定义L的一个子表，从而产生n个子问题，即分别由这n个子串（递归）建立n个子表，再组合成一个广义表。

其中：

可以直接求解的两种简单情况为：

以串‘（）’建立的广义表是空表，由单字符建立的广义表只是一个原子结点。

若是其他情况，因为第一个子表的标志域为一，代表指向广义表的头指针。

指示表头的指针域指向第一个子表的头指针。

相邻子表之间用表结点相连接。

综上：

若S='（）'则L=NIL；否则，构造第一个表结点*L，并从串S中分解出第一个子串α1，对应创建第一个子广义表L->ptr.hp;若剩余串非空，则构造第二个表结点L->ptr.tp，并从串S中分解出第二个字串α2，对应创建第二个子广义表……以此类推直至剩余串为空串止。

6.由广义表到广义表的字符串形式

7.求深度：

广义表深度定义为广义表中括弧的重数，是广义表的一种量度。

例如，多元多项式广义表的深度为多项式中变元的个数。

设非空广义表为LS=（α1，α2，…αn）其中αi（i=1，2，3…）或为原子或为LS的子表，则求LS的深度可分解为n个子问题，每个子问题为求αi的深度，若αi是原子，则由定义其深度为零，若αi是广义表，则和上述一样处理，而LS的深度为各αi（i=1，2，3…）的深度中最大值加一。

空表也是广义表，并由定义可知空表的深度为1。

由此可见，求广义表的深度递归算法有两个终结态：

空表和原子，且只要求得αi（i=1，2，3，…）的深度，广义表的深度就容易求得了。

显然，它应比子表深度的最大值多1.

广义表LS=（α1，α2，…αn）的深度DEPTH（LS）的递归定义为

基本项：

ＤＥＰＴＨ（ＬＳ）＝１　　当ＬＳ为空表时

　　　　　　ＤＥＰＴＨ（ＬＳ）＝０　　当ＬＳ为原子时

归纳项：

ＤＥＰＴＨ（ＬＳ）＝１＋Ｍａｘ｛ＤＥＰＴＨ（αｉ）｝　ｎ＞＝１

由此定义容易写出求深度的递归函数。

假设Ｌ是ＧＬｉｓｔ型的变量则Ｌ＝ＮＵＬＬ表明广义表为空表，Ｌ－＞ｔａｇ＝０表明是原子。

反之，Ｌ指向表结点，该结点中的ｈｐ指针指向表头，即为Ｌ的第一个子表，而结点中的ｔｐ指针所指表尾结点中的ｈｐ指针指向Ｌ的第二个子表。

在第一层中由ｔｐ相连的所有尾结点中的ｈｐ指针均指向Ｌ的子表。

由此可得广义表深度的递归算法。

2程序实现

上机实现算法时由于具体问题牵涉到各种方面，难以综合实现，可以分为几个小的模块将程序先进行初步整合

具体程序：

#include

#include

#include

classGenListNode{

friendclassGenList;

public:

intutype;//0,1,2,3

union{

intintinfo;

charcharinfo;

GenListNode*hlink;

}value;

GenListNode*tlink;

GenListNode（）{}

};

classGenList{

public:

GenListNode*first;

intSever（char*&hstr,char*&s）;

voidstrncpy1（char*&hstr,char*&s,intcomma）;

GenListNode*CreatList（char*s）;

voidCreat（char*s）;

voidDisplay（void）;

voidDisplay（char*s,GenListNode*ls）;

voidshow（GenListNode*ls）;

voidhead（GenListNode*&u）;

voidtail（GenListNode*&u）;

intdisplay（GenListNode*u1,GenListNode*u）;

voidfind（char*s,GenListNode*&u）;

};

voidGenList:

:

Creat（char*s）

{

first=CreatList（s）;

}

GenListNode*GenList:

:

CreatList（char*s）

{

GenListNode*ls,*head;

ls=newGenListNode（）;

head=ls;

ls->utype=0;

if（strlen（s）<=2）

{

ls->tlink=NULL;

}else{

char*sub;

while（strlen（s）>2）{

ls=ls->tlink=newGenListNode（）;

ls->utype=Sever（sub,s）;

switch（ls->utype）{

case1:

ls->value.intinfo=atoi（sub）;break;

case2:

ls->value.charinfo=sub[0];break;

case3:

ls->value.hlink=CreatList（sub）;break;

}

}

ls->tlink=NULL;

}

returnhead;

}

intGenList:

:

Sever（char*&hstr,char*&s）

{

charch=s[0];

intn=strlen（s）;

inti=0,k=0,comma=-1;

intx=0,y=0;

while（i

=','||k!

=0））{

if（ch=='（'）{k++;}

else{

if（ch=='）'）{k--;}

}

i++;

ch=s[i];

if（ch==','&&x==0）{x=10;comma=i;}

if（k==1&&x<8）{x++;if（x==2）{comma=i;}}

}

if（k!

=0）{

cout<<"括号不配对!

退出程序!

"<

exit

（1）;

}

if（comma==-1）{comma=n;}

strncpy1（hstr,s,comma）;//分割字符串

if（strlen（hstr）>=3）{return3;}

else{

if（hstr[0]<='9'&&hstr[0]>='0'）{return1;}

if（hstr[0]<='z'&&hstr[0]>='a'）{return2;}

}

return1;

}

voidGenList:

:

strncpy1（char*&hstr,char*&s,intcomma）{

intn=strlen（s）;

hstr=newchar[n];

for（intt=0,i=1;i

hstr[t]=s[i];

t++;

}

hstr[t]='\0';

for（t=1,i=comma+1;i

{s[t]=s[i];}

s[t]='\0';

if（t==1）{s[1]='）';s[2]='\0';}

}

voidGenList:

:

Display（void）{

show（first）;

}

voidGenList:

:

Display（char*s,GenListNode*ls）

{

inti=0;

if（ls->utype==0）{

while（ls!

=NULL）{

switch（ls->utype）{

case0:

s[i]='（';i++;cout<<"（";break;

case1:

s[i]='0'+（ls->value.intinfo-0）;i++;cout<value.intinfo;if（ls->tlink!

=NULL）{s[i]=',';i++;cout<<",";}break;

case2:

s[i]=ls->value.charinfo;i++;cout<value.charinfo;if（ls->tlink!

=NULL）{s[i]=',';i++;cout<<",";}break;

case3:

show（ls->value.hlink）;if（ls->tlink!

=NULL）{s[i]=',';i++;cout<<",";}break;

}

ls=ls->tlink;

}

s[i]='）';i++;

cout<<"）"<

s[i]='\0';

}else{

while（ls!

=NULL）{

switch（ls->utype