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

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

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

一个表结点可由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<

iostream.h>

string.h>

cstdlib>

classGenListNode{

friendclassGenList;

public:

intutype;

//0,1,2,3

union{

intintinfo;

charcharinfo;

GenListNode*hlink;

}value;

GenListNode*tlink;

GenListNode（）{}

};

classGenList{

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*&

intdisplay（GenListNode*u1,GenListNode*u）;

voidfind（char*s,GenListNode*&

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:

value.charinfo=sub[0];

case3:

value.hlink=CreatList（sub）;

}

}

}

returnhead;

intGenList:

Sever（char*&

s）

charch=s[0];

intn=strlen（s）;

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

intx=0,y=0;

while（i<

n&

&

（ch!

='

'

||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<

<

"

括号不配对!

退出程序!

endl;

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;

z'

a'

）{return2;

return1;

strncpy1（char*&

s,intcomma）{

intn=strlen（s）;

hstr=newchar[n];

for（intt=0,i=1;

i<

comma;

i++）{

hstr[t]=s[i];

t++;

hstr[t]='

\0'

;

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

n;

t++,i++）

{s[t]=s[i];

s[t]='

if（t==1）{s[1]='

s[2]='

Display（void）{

show（first）;

Display（char*s,GenListNode*ls）

inti=0;

if（ls->

utype==0）{

while（ls!

=NULL）{

switch（ls->

case0:

s[i]='

i++;

cout<

（"

break;

case1:

+（ls->

value.intinfo-0）;

value.intinfo;

if（ls->

tlink!

=NULL）{s[i]='

"

}break;

case2:

s[i]=ls->

value.charinfo;

case3:

show（ls->

value.hlink）;

}break;

ls=ls->

tlink;

s[i]='

cout<

）"

while（ls!

utype