数据结构第二章练习题答案.docx
《数据结构第二章练习题答案.docx》由会员分享，可在线阅读，更多相关《数据结构第二章练习题答案.docx（24页珍藏版）》请在冰豆网上搜索。
数据结构第二章练习题答案
/*文件名:
exp2-1.cpp*/
#include
#include
#defineMaxSize50
typedefcharElemType;
typedefstruct
{
ElemTypedata[MaxSize];
intlength;
}SqList;
externvoidInitList（SqList*&L）;
externvoidDestroyList（SqList*L）;
externintListEmpty（SqList*L）;
externintListLength（SqList*L）;
externvoidDispList（SqList*L）;
externintGetElem（SqList*L,inti,ElemType&e）;
externintLocateElem（SqList*L,ElemTypee）;
externintListInsert（SqList*&L,inti,ElemTypee）;
externintListDelete（SqList*&L,inti,ElemType&e）;
voidmain（）
{
SqList*L;
ElemTypee;
printf（"
（1）初始化顺序表L\n"）;
InitList（L）;
printf（"
（2）依次采用尾插法插入a,b,c,d,e元素\n"）;
ListInsert（L,1,'a'）;
ListInsert（L,2,'b'）;
ListInsert（L,3,'c'）;
ListInsert（L,4,'d'）;
ListInsert（L,5,'e'）;
printf（"（3）输出顺序表L:
"）;
DispList（L）;
printf（"（4）顺序表L长度=%d\n",ListLength（L））;
printf（"（5）顺序表L为%s\n",（ListEmpty（L）?
"空":
"非空"））;
GetElem（L,3,e）;
printf（"（6）顺序表L的第3个元素=%c\n",e）;
printf（"（7）元素a的位置=%d\n",LocateElem（L,'a'））;
printf（"（8）在第4个元素位置上插入f元素\n"）;
ListInsert（L,4,'f'）;
printf（"（9）输出顺序表L:
"）;
DispList（L）;
printf（"（10）删除L的第3个元素\n"）;
ListDelete（L,3,e）;
printf（"（11）输出顺序表L:
"）;
DispList（L）;
printf（"（12）释放顺序表L\n"）;
DestroyList（L）;
}
//文件名:
exp2-2.cpp
#include
#include
usingnamespacestd;
typedefstructLNode//定义单链表结点类型
{
stringdata;
structLNode*next;
}LinkList;
voidInitList（LinkList*&L）
{
L=（LinkList*）malloc（sizeof（LinkList））;//创建头结点
L->next=NULL;
}
voidDestroyList（LinkList*&L）
{
LinkList*p=L,*q=p->next;
while（q!
=NULL）
{
free（p）;
p=q;
q=p->next;
}
free（p）;
}
intListEmpty（LinkList*L）
{
return（L->next==NULL）;
}
/*intListLength（LinkList*L）
{
LinkList*p=L;inti=0;
while（p->next!
=NULL）
{
i++;
p=p->next;
}
return（i）;
}
voidDispList（LinkList*L）
{
LinkList*p=L->next;
while（p!
=NULL）
{
printf（"%s",p->data）;
p=p->next;
}
printf（"\n"）;
}
intGetElem（LinkList*L,inti,ElemType&e）
{
intj=0;
LinkList*p=L;
while（j=NULL）
{
j++;
p=p->next;
}
if（p==NULL）
return0;
else
{
e=p->data;
return1;
}
}
intLocateElem（LinkList*L,ElemTypee）
{
LinkList*p=L->next;
intn=1;
while（p!
=NULL&&p->data!
=e）
{
p=p->next;
n++;
}
if（p==NULL）
return（0）;
else
return（n）;
}*/
intListInsert（LinkList*&L,inti,stringe）
{
intj=0;
LinkList*p=L,*s;
while（j=NULL）
{
j++;
p=p->next;
}
if（p==NULL）//未找到第i-1个结点
return0;
else//找到第i-1个结点*p
{
s=（LinkList*）malloc（sizeof（LinkList））;//创建新结点*s
s->data=e;
s->next=p->next;//将*s插入到*p之后
p->next=s;
return1;
}
}
/*intListDelete（LinkList*&L,inti,ElemType&e）
{
intj=0;
LinkList*p=L,*q;
while（j=NULL）
{
j++;
p=p->next;
}
if（p==NULL）//未找到第i-1个结点
return0;
else//找到第i-1个结点*p
{
q=p->next;//q指向要删除的结点
if（q==NULL）return0;
e=q->data;
p->next=q->next;//从单链表中删除*q结点
free（q）;//释放*q结点
return1;
}
}
*/
voidmain（）
{
LinkList*h;
stringe;
printf（"
（1）初始化单链表h\n"）;
InitList（h）;
printf（"
（2）依次采用尾插法插入a,b,c,d,e元素\n"）;
ListInsert（h,1,"a"）;
/*ListInsert（h,2,'b'）;
ListInsert（h,3,'c'）;
ListInsert（h,4,'d'）;
ListInsert（h,5,'e'）;
printf（"（3）输出单链表h:
"）;
DispList（h）;
printf（"（4）单链表h长度=%d\n",ListLength（h））;
printf（"（5）单链表h为%s\n",（ListEmpty（h）?
"空":
"非空"））;
GetElem（h,3,e）;
printf（"（6）单链表h的第3个元素=%c\n",e）;
printf（"（7）元素a的位置=%d\n",LocateElem（h,'a'））;
printf（"（8）在第4个元素位置上插入f元素\n"）;
ListInsert（h,4,'f'）;
printf（"（9）输出单链表h:
"）;
DispList（h）;
printf（"（10）删除h的第3个元素\n"）;
ListDelete（h,3,e）;
printf（"（11）输出单链表h:
"）;
DispList（h）;
printf（"（12）释放单链表h\n"）;
DestroyList（h）;*/
}
//文件名:
exp2-3.cpp
#include
#include
typedefcharElemType;
typedefstructDNode//定义双链表结点类型
{
ElemTypedata;
structDNode*prior;//指向前驱结点
structDNode*next;//指向后继结点
}DLinkList;
externvoidInitList（DLinkList*&L）;//以下均为外部函数
externvoidDestroyList（DLinkList*&L）;
externintListEmpty（DLinkList*L）;
externintListLength（DLinkList*L）;
externvoidDispList（DLinkList*L）;
externintGetElem（DLinkList*L,inti,ElemType&e）;
externintLocateElem（DLinkList*L,ElemTypee）;
externintListInsert（DLinkList*&L,inti,ElemTypee）;
externintListDelete（DLinkList*&L,inti,ElemType&e）;
voidmain（）
{
DLinkList*h;
ElemTypee;
printf（"
（1）初始化双链表h\n"）;
InitList（h）;
printf（"
（2）依次采用尾插法插入a,b,c,d,e元素\n"）;
ListInsert（h,1,'a'）;
ListInsert（h,2,'b'）;
ListInsert（h,3,'c'）;
ListInsert（h,4,'d'）;
ListInsert（h,5,'e'）;
printf（"（3）输出双链表h:
"）;
DispList（h）;
printf（"（4）双链表h长度=%d\n",ListLength（h））;
printf（"（5）双链表h为%s\n",（ListEmpty（h）?
"空":
"非空"））;
GetElem（h,3,e）;
printf（"（6）双链表h的第3个元素=%c\n",e）;
printf（"（7）元素a的位置=%d\n",LocateElem（h,'a'））;
printf（"（8）在第4个元素位置上插入f元素\n"）;
ListInsert（h,4,'f'）;
printf（"（9）输出双链表h:
"）;
DispList（h）;
printf（"（10）删除h的第3个元素\n"）;
ListDelete（h,3,e）;
printf（"（11）输出双链表h:
"）;
DispList（h）;
printf（"（12）释放双链表h\n"）;
DestroyList（h）;
}
//文件名:
exp2-4.cpp
#include
#include
typedefcharElemType;
typedefstructLNode//定义循环单链表结点类型
{
ElemTypedata;
structLNode*next;
}LinkList;
externvoidInitList（LinkList*&L）;//以下均为外部函数
externvoidDestroyList（LinkList*&L）;
externintListEmpty（LinkList*L）;
externintListLength（LinkList*L）;
externvoidDispList（LinkList*L）;
externintGetElem（LinkList*L,inti,ElemType&e）;
externintLocateElem（LinkList*L,ElemTypee）;
externintListInsert（LinkList*&L,inti,ElemTypee）;
externintListDelete（LinkList*&L,inti,ElemType&e）;
voidmain（）
{
LinkList*h;
ElemTypee;
printf（"
（1）初始化循环单链表h\n"）;
InitList（h）;
printf（"
（2）依次采用尾插法插入a,b,c,d,e元素\n"）;
ListInsert（h,1,'a'）;
ListInsert（h,2,'b'）;
ListInsert（h,3,'c'）;
ListInsert（h,4,'d'）;
ListInsert（h,5,'e'）;
printf（"（3）输出循环单链表h:
"）;
DispList（h）;
printf（"（4）循环单链表h长度=%d\n",ListLength（h））;
printf（"（5）循环单链表h为%s\n",（ListEmpty（h）?
"空":
"非空"））;
GetElem（h,3,e）;
printf（"（6）循环单链表h的第3个元素=%c\n",e）;
printf（"（7）元素a的位置=%d\n",LocateElem（h,'a'））;
printf（"（8）在第4个元素位置上插入f元素\n"）;
ListInsert（h,4,'f'）;
printf（"（9）输出循环单链表h:
"）;
DispList（h）;
printf（"（10）删除h的第3个元素\n"）;
ListDelete（h,3,e）;
printf（"（11）输出循环单链表h:
"）;
DispList（h）;
printf（"（12）释放循环单链表h\n"）;
DestroyList（h）;
}
//文件名:
exp2-5.cpp
#include
typedefcharElemType;
typedefstructDNode//定义循环双链表结点类型
{
ElemTypedata;
structDNode*prior,*next;
}DLinkList;
externvoidInitList（DLinkList*&L）;//以下均为外部函数
externvoidDestroyList（DLinkList*&L）;
externintListEmpty（DLinkList*L）;
externintListLength（DLinkList*L）;
externvoidDispList（DLinkList*L）;
externintGetElem（DLinkList*L,inti,ElemType&e）;
externintLocateElem（DLinkList*L,ElemTypee）;
externintListInsert（DLinkList*&L,inti,ElemTypee）;
externintListDelete（DLinkList*&L,inti,ElemType&e）;
voidmain（）
{
DLinkList*h;
ElemTypee;
printf（"
（1）初始化循环双链表h\n"）;
InitList（h）;
printf（"
（2）依次采用尾插法插入a,b,c,d,e元素\n"）;
ListInsert（h,1,'a'）;
ListInsert（h,2,'b'）;
ListInsert（h,3,'c'）;
ListInsert（h,4,'d'）;
ListInsert（h,5,'e'）;
printf（"（3）输出循环双链表h:
"）;
DispList（h）;
printf（"（4）循环双链表h长度=%d\n",ListLength（h））;
printf（"（5）循环双链表h为%s\n",（ListEmpty（h）?
"空":
"非空"））;
GetElem（h,3,e）;
printf（"（6）循环双链表h的第3个元素=%c\n",e）;
printf（"（7）元素a的位置=%d\n",LocateElem（h,'a'））;
printf（"（8）在第4个元素位置上插入f元素\n"）;
ListInsert（h,4,'f'）;
printf（"（9）输出循环双链表h:
"）;
DispList（h）;
printf（"（10）删除h的第3个元素\n"）;
ListDelete（h,3,e）;
printf（"（11）输出循环双链表h:
"）;
DispList（h）;
printf（"（12）释放循环双链表h\n"）;
DestroyList（h）;
}
//文件名:
exp2-6.cpp
#include
#include
typedefcharElemType;
typedefstructLNode//定义单链表结点类型
{
ElemTypedata;
structLNode*next;
}LinkList;
externvoidDispList（LinkList*L）;
voidCreateListR（LinkList*&L,ElemTypea[],intn）//尾插法建表
{
LinkList*s,*r;inti;
L=（LinkList*）malloc（sizeof（LinkList））;//创建头结点
L->next=NULL;
r=L;//r始终指向终端结点,开始时指向头结点
for（i=0;i{
s=（LinkList*）malloc（sizeof（LinkList））;//创建新结点
s->data=a[i];
r->next=s;//将*s插入*r之后
r=s;
}
r->next=NULL;//终端结点next域置为NULL
}
voidSort（LinkList*&head）//单链表元素排序
{
LinkList*p=head->next,*q,*r;
if（p!
=NULL）//若原单链表中有一个或以上的数据结点
{
r=p->next;//r保存*p结点后继结点的指针
p->next=NULL;//构造只含一个数据结点的有序表
p=r;
while（p!
=NULL）
{
r=p->next;//r保存*p结点后继结点的指针
q=head;
while（q->next!
=NULL&&q->next->datadata）//在有序表中找插入*p的前驱结点*q
q=q->next;
p->next=q->next;//将*p插入到*q之后
q->next=p;
p=r;
}
}
}
voidUnion（LinkList*ha,LinkList*hb,LinkList*&hc）//求两有序集合的并
{
LinkList*pa=ha->next,*pb=hb->next,*s,*tc;
hc=（LinkList*）malloc（sizeof（LinkList））;//创建头结点
tc=hc;
while（pa!
=NULL&&pb!
=NULL）
{
if（pa->datadata）
{
s=（LinkList*）malloc（sizeof（LinkList））;//复制结点
s->data=pa->data;
tc->next=s;tc=s;
pa=pa->next;
}
elseif（pa->data>pb->data）
{
s=（LinkList*）malloc（sizeof（LinkList））;//复制结点
s->data=pb->data;
tc->next=s;tc=s;
pb=pb->next;
}
else
{
s=（LinkList*）malloc（sizeof（LinkList））;//复制结点
s->data=pa->data;
tc->next=s;tc=s;
pa=pa->next;//重复的元素只复制一个
pb=pb->next;
}
}
if（pb!
=NULL）pa=pb;//复制余下的结点
while（pa!
=NULL）
{
s=（LinkList*）malloc（sizeof（LinkList））;//复制结点
s->data=pa->data;
tc->next=s;tc=s;
pa=pa->next;
}
tc->next=NULL;
}
voidInterSect（LinkList*ha,LinkList*hb,LinkList*&hc）//求两有序集合的差
{
LinkList*pa=ha->next,*pb,*s,*tc;
hc=（LinkList*）malloc（sizeof（LinkList））;
tc=hc;
while（pa!
=NULL）
{
pb=hb->next;
while（pb!
=NULL&&pb->datadata）
pb=pb->next;
if（pb!
=NULL&&pb->data==pa->data）//若pa结点值在B中
{
s=（LinkList*）malloc（sizeof（LinkList））;//复制结点
s->data=pa->data;
tc->next=s;tc=s;
升级会员 