数据结构第二章习题答案Word格式文档下载.docx
《数据结构第二章习题答案Word格式文档下载.docx》由会员分享，可在线阅读，更多相关《数据结构第二章习题答案Word格式文档下载.docx（13页珍藏版）》请在冰点文库上搜索。
if（L&
&
L->
next）{
Q=L;
L=L->
next;
P=L;
while（P->
next）P=P->
P->
next=Q;
Q->
next=NULL;
}
returnL;
}//Demo
该算法的功能是：
将开始结点摘下链接到终端结点之后成为新的终端结点，而原来的第二个结点成为新的开始结点，返回新链表的头指针。
2.7设线性表的n个结点定义为（a0,a1,...an-1），重写顺序表上实现的插入和删除算法：
InsertList和DeleteList.
解：
算法如下:
#defineListSize100//假定表空间大小为100
typedefintDataType;
//假定DataType的类型为int型
typedefstruct{
DataTypedata[ListSize];
//向量data用于存放表结点
intlength;
//当前的表长度
}Seqlist;
//以上为定义表结构
voidInsertList（Seqlist*L,Datatypex,inti）
{
//将新结点x插入L所指的顺序表的第i个结点ai的位置上，即插入的合法位置为：
0<
=i<
=L->
length
intj;
if（i<
0||i>
L->
length）
Error（"
positionerror"
）;
//非法位置，退出，该函数定义见教材P7.
if（L->
length>
=ListSize）
Error（“overflow"
for（j=L->
length-1;
j>
=i;
j--）
L->
data[j+1]=L->
data[j];
data[i]=x;
length++;
}
voidDeleteList（Seqlist*L,inti）
{//从L所指的顺序表中删除第i个结点ai,合法的删除位置为0<
length-1
if（i<
=L->
length）
Error（"
positionerror"
）;
for（j=i;
j<
length;
j++）
data[j]=L->
data[j+1];
//结点前移
length--;
//表长减小
2.8试分别用顺序表和单链表作为存储结构，实现将线性表（a0,a1,...an-1）就地逆置的操作，所谓"
就地"
指辅助空间应为O
（1）。
1.顺序表：
要将该表逆置，可以将表中的开始结点与终端结点互换，第二个结点与倒数第二个结点互换，如此反复，就可将整个表逆置了。
算法如下：
//顺序表结构定义同上题
voidReverseList（Seqlist*L）
{
DataTypetemp;
//设置临时空间用于存放data
inti;
for（i=0;
i<
length/2;
i++）//L->
length/2为整除运算
{temp=L->
data[i];
//交换数据
L->
data[i]=L->
data[L->
length-1-i];
length-1-i]=temp;
}
2.链表：
分析：
可以用交换数据的方式来达到逆置的目的。
但是由于是单链表，数据的存取不是随机的，因此算法效率太低。
可以利用指针改指来达到表逆置的目的。
具体情况入下：
（1）当链表为空表或只有一个结点时，该链表的逆置链表与原表相同。
（2）当链表含2个以上结点时，可将该链表处理成只含第一结点的带头结点链表和一个无头结点的包含该链表剩余结点的链表。
然后，将该无头结点链表中的所有结点顺着链表指针，由前往后将每个结点依次从无头结点链表中摘下，作为第一个结点插入到带头结点链表中。
这样就可以得到逆置的链表。
算法是这样的：
结点结构定义如下：
typedefcharDataType;
//假设结点的数据域类型的字符
typedefstructnode{//结点类型定义
DataTypedata;
//结点的数据域
structnode*next;
//结点的指针域
}ListNode;
typedefListNode*LinkList;
ListNode*p;
LinkListhead;
LinkListReverseList（LinkListhead）
{//将head所指的单链表（带头结点）逆置
ListNode*p,*q;
//设置两个临时指针变量
if（head->
next&
head->
next）
{
//当链表不是空表或单结点时
p=head->
q=p->
p->
next=NULL;
//将开始结点变成终端结点
while（q）
{//每次循环将后一个结点变成开始结点
p=q;
q=q->
next;
p->
next=head->
next;
head->
next=p;
}
returnhead;
}
returnhead;
//如是空表或单结点表，直接返回head
}
2.9设顺序表L是一个递增有序表，试写一算法，将x插入L中，并使L仍是一个有序表。
因已知顺序表L是递增有序表，所以只要从顺序表终端结点（设为i位置元素）开始向前寻找到第一个小于或等于x的元素位置i后插入该位置即可。
在寻找过程中，由于大于x的元素都应放在x之后，所以可边寻找，边后移元素，当找到第一个小于或等于x的元素位置i时，该位置也空出来了。
算法如下：
//顺序表存储结构如题2.7
voidInsertIncreaseList（Seqlist*L,Datatypex）
inti;
if（L->
=ListSize）
Error（“overflow"
for（i=L->
i>
0&
data[i-1]>
x;
i--）
L->
data[i]=L->
data[i];
//比较并移动元素
L->
data[i]=x;
L->
length++;
2.10设顺序表L是一个递减有序表，试写一算法，将x插入其后仍保持L的有序性。
与上题相类似，只要从终端结点开始往前找到第一个比x大（或相等）的结点数据，在这个位置插入就可以了。
（边寻找，边移动）算法如下：
voidInsertDecreaseList（Seqlist*L,Datatypex）
{
inti;
if（L->
Error（“overflow"
for（i=L->
data[i-1]<
L->
L->
L->
2.11写一算法在单链表上实现线性表的ListLength（L）运算。
由于在单链表中只给出一个头指针，所以只能用遍历的方法来数单链表中的结点个数了。
intListLength（LinkListL）
intlen=0;
p=L;
//设该表有头结点
while（p->
next）
{
p=p->
len++;
returnlen;
2.12已知L1和L2分别指向两个单链表的头结点，且已知其长度分别为m和n。
试写一算法将这两个链表连接在一起，请分析你的算法的时间复杂度。
由于要进行的是两单链表的连接，所以应找到放在前面的那张表的表尾结点，再将后表的开始结点链接到前表的终端结点后即可。
该算法的主要时间消耗是用在寻找第一张表的终端尾结点上。
这两张单链表的连接顺序无要求，并且已知两表的表长，则为了提高算法效率，可选表长小的单链表在前的方式连接。
具体算法如下：
LinkListLink（LinkListL1,LinkListL2，intm,intn）
{//将两个单链表连接在一起
ListNode*p,*q,*s;
//s指向短表的头结点,q指向长表的开始结点，回收长表头结点空间
if（m<
=n）
{s=L1;
q=L2->
free（L2）;
else{s=L2;
q=L1->
free（L1）;
p=s;
next）p=p->
//查找短表终端结点
p->
next=q;
//将长表的开始结点链接在短表终端结点后
returns;
本算法的主要操作时间花费在查找短表的终端结点上，所以本算的法时间复杂度为：
O（min（m,n））
2.13设A和B是两个单链表，其表中元素递增有序。
试写一算法将A和B归并成一个按元素值递减有序的单链表C，并要求辅助空间为O
（1），请分析算法的时间复杂度。
根据已知条件，A和B是两个递增有序表，所以可以先取A表的表头建立空的C表。
然后同时扫描A表和B表，将两表中最大的结点从对应表中摘下，并作为开始结点插入C表中。
如此反复，直到A表或B表为空。
最后将不为空的A表或B表中的结点依次摘下并作为开始结点插入C表中。
这时，得到的C表就是由A表和B表归并成的一个按元素值递减有序的单链表C。
并且辅助空间为O
（1）。
LinkListMergeSort（LinkListA,LinkListB）
{//归并两个带头结点的递增有序表为一个带头结点递减有序表
ListNode*pa,*pb,*q,*C;
pa=A->
//pa指向A表开始结点
C=A;
C->
//取A表的表头建立空的C表
pb=B->
//pb指向B表开始结点
free（B）;
//回收B表的头结点空间
while（pa&
pb）
if（pb->
data<
=pa->
data）
{//当B中的元素小于等于A中当前元素时，将pa表的开始结点摘下
q=pa;
pa=pa->
else
{//当B中的元素大于A中当前元素时，将pb表的开始结点摘下
q=pb;
pb=pb->
q->
next=C->
next=q;
//将摘下的结点q作为开始结点插入C表
//若pa表非空，则处理pa表
while（pa）{
q=pa;
//若pb表非空，则处理pb表
while（pb）{
q=pb;
pa=pb->
return（C）;
}
该算法的时间复杂度分析如下：
算法中有三个while循环，其中第二个和第三个循环只执行一个。
每个循环做的工作都是对链表中结点扫描处理。
整个算法完成后，A表和B表中的每个结点都被处理了一遍。
所以若A表和B表的表长分别是m和n，则该算法的时间复杂度O（m+n）
2.14已知单链表L是一个递增有序表，试写一高效算法，删除表中值大于min且小于max的结点（若表中有这样的结点），同时释放被删结点的空间，这里min和max是两个给定的参数。
请分析你的算法的时间复杂度。
要解这样的问题，我们首先想到的是拿链表中的元素一个个地与max和min比较，然后删除这个结点。
由于为已知其是有序链表，则介于min和max之间的结点必为连续的一段元素序列。
所以我们只要先找到所有大于min结点中的最小结点的直接前趋结点*p后，依次删除小于max的结点，直到第一个大于等于max结点*q位置，然后将*p结点的直接后继指针指向*q结点。
voidDeleteList（LinkListL,DataTypemin,DataTypemax）
ListNode*p,*q,*s;
while（p->
p->
=min）
//找比min大的前一个元素位置
p=p->
q=p->
//p指向第一个不大于min结点的直接前趋，q指向第一个大于min的结点
while（q&
q->
data<
max）
{s=q;
q=q->
free（s）;
//删除结点，释放空间
//将*p结点的直接后继指针指向*q结点
2.15写一算法将单链表中值重复的结点删除，使所得的结果表中各结点值均不相同。
本题可以这样考虑，先取开始结点中的值，将它与其后的所有结点值一一比较，发现相同的就删除掉，然后再取第二结点的值，重复上述过程直到最后一个结点。
具体算法：
voidDeleteList（LinkListL）
{
ListNode*p,*q,*s;
p=L-next;
while（p->
next&
p->
{
q=p;
//由于要做删除操作，所以q指针指向要删除元素的直接前趋
while（q->
if（p->
data==q->
data）
{s=q->
next=s->
free（s）;
//删除与*p的值相同的结点
}
elseq=q->
p=p->
}
}
2.16假设在长度大于1的单循环链表中，既无头结点也无头指针。
s为指向链表中某个结点的指针，试编写算法删除结点*s的直接前趋结点。
已知指向这个结点的指针是*s，那么要删除这个结点的直接前趋结点，就只要找到一个结点，它的指针域是指向*s的直接前趋，然后用后删结点法，将结点*s的直接前趋结点删除即可。
voidDeleteNode（ListNode*s）
{//删除单循环链表中指定结点的直接前趋结点
ListNode*p,*q;
p=s;
while（p->
next!
=s）
//删除结点
p->
next=q->
free（p）;
//释放空间
注意：
若单循环链表的长度等于1，则只要把表删空即可。
2.17已知由单链表表示的线性表中，含有三类字符的数据元素（如：
字母字符、数字字符和其它字符），试编写算法构造三个以循环链表表示的线性表，使每个表中只含同一类的字符，且利用原表中的结点空间作为这三个表的结点空间，头结点可另辟空间。
要解决这样的问题，只要新建三个头结点，然后在原来的单链表中依次查询，找到一类字符结点时，就摘下此结点链接到相应头结点指明的新链表中就是了。
//设已建立三个带头结点的空循环链表A,B,C且A、B、C分别是尾指针.
voidDivideList（LinkListL,LinkListA,LinkListB,LinkListC）
ListNode*p=L->
next,*q;
while（p）
if（p->
data>
='
a'
&
z'
||p->
A'
Z'
）
{
q=p->
p=p->
//指向下一结点
q->
next=A->
//将字母结点链到A表中
A->
A=q;
elseif（p->
0'
9'
{//分出数字结点
q=p->
p=p->
q->
next=B->
//将数字结点链到B表中
B->
B=q;
else{//分出其他字符结点
q=p->
p=p->
q->
//将其他结点链到C表中
C->
C=q;
}
}//结束
2.18设有一个双链表，每个结点中除有prior、data和next三个域外，还有一个访问频度域freq，在链表被起用之前，其值均初始化为零。
每当在链表进行一次LocateNode（L,x）运算时，令元素值为x的结点中freq域的值加1，并调整表中结点的次序，使其按访问频度的递减序排列，以便使频繁访问的结点总是靠近表头。
试写一符合上述要求的LocateNode运算的算法。
LocateNode运算的基本思想就是在双向链表中查找值为x的结点，具体方法与单链表中查找一样。
找到结点*p后给freq域的值加1。
由于原来比*p结点查找频度高的结点都排它前面，所以，接下去要顺着前趋指针找到第一个频度小于或等于*p结点频度的结点*q后，将*p结点从原来的位置删除，并插入到*q后就可以了。
//双向链表的存储结构
typedefstructdlistnode{
DataTypedata;
structdlistnode*prior,*next;
intfreq;
}DListNode;
typedef
升级会员 