第二章线性表习题及答案.docx
《第二章线性表习题及答案.docx》由会员分享，可在线阅读，更多相关《第二章线性表习题及答案.docx（25页珍藏版）》请在冰豆网上搜索。
第二章线性表习题及答案
第二章线性表习题及答案
一、基础知识题
2.1试描述头指针、头结点、开始结点的区别、并说明头指针和头结点的作用。
答：
始结点是指链表中的第一个结点，也就是没有直接前趋的那个结点。
链表的头指针是一指向链表开始结点的指针（没有头结点时），单链表由头指针唯一确定，因此单链表可以用头指针的名字来命名。
头结点是我们人为地在链表的开始结点之前附加的一个结点。
有了头结点之后，头指针指向头结点，不论链表否为空，头指针总是非空。
而且头指针的设置使得对链表的第一个位置上的操作与在表其他位置上的操作一致（都是在某一结点之后）。
2.2何时选用顺序表、何时选用链表作为线性表的存储结构为宜?
答：
在实际应用中，应根据具体问题的要求和性质来选择顺序表或链表作为线性表的存储结构，通常有以下几方面的考虑：
1.基于空间的考虑。
当要求存储的线性表长度变化不大，易于事先确定其大小时，为了节约存储空间，宜采用顺序表；反之，当线性表长度变化大，难以估计其存储规模时，采用动态链表作为存储结构为好。
2.基于时间的考虑。
若线性表的操作主要是进行查找，很少做插入和删除操作时，采用顺序表做存储结构为宜；反之，若需要对线性表进行频繁地插入或删除等的操作时，宜采用链表做存储结构。
并且，若链表的插入和删除主要发生在表的首尾两端，则采用尾指针表示的单循环链表为宜。
2.3在顺序表中插入和删除一个结点需平均移动多少个结点?
具体的移动次数取决于哪两个因素?
答：
在等概率情况下，顺序表中插入一个结点需平均移动n/2个结点。
删除一个结点需平均移动（n-1）/2个结点。
具体的移动次数取决于顺序表的长度n以及需插入或删除的位置i。
i越接近n则所需移动的结点数越少。
2.4为什么在单循环链表中设置尾指针比设置头指针更好?
答：
尾指针是指向终端结点的指针，用它来表示单循环链表可以使得查找链表的开始结点和终端结点都很方便，设一带头结点的单循环链表，其尾指针为rear，则开始结点和终端结点的位置分别是rear->next->next和rear,查找时间都是O
（1）。
若用头指针来表示该链表，则查找终端结点的时间为O（n）。
2.5在单链表、双链表和单循环链表中，若仅知道指针p指向某结点，不知道头指针，能否将结点*p从相应的链表中删去?
若可以，其时间复杂度各为多少?
答：
我们分别讨论三种链表的情况。
1.单链表。
当我们知道指针p指向某结点时，能够根据该指针找到其直接后继，但是由于不知道其头指针，所以无法访问到p指针指向的结点的直接前趋。
因此无法删去该结点。
2.双链表。
由于这样的链表提供双向链接，因此根据已知结点可以查找到其直接前趋和直接后继，从而可以删除该结点。
其时间复杂度为O
（1）。
3.单循环链表。
根据已知结点位置，我们可以直接得到其后相邻的结点位置（直接后继），又因为是循环链表，所以我们可以通过查找，得到p结点的直接前趋。
因此可以删去p所指结点。
其时间复杂度应为O（n）。
2.6下述算法的功能是什么?
LinkListDemo（LinkListL）{//L是无头结点单链表
ListNode*Q,*P;
if（L&&L->next）{
Q=L;L=L->next;P=L;
while（P->next）P=P->next;
P->next=Q;Q->next=NULL;}}
答：
该算法的功能是：
将开始结点摘下链接到终端结点之后成为新的终端结点，而原来的第二个结点成为新的开始结点，返回新链表的头指针。
二、算法设计题
2.7设线性表的n个结点定义为（a0,a1,...an-1），重写顺序表上实现的插入和删除算法：
InsertList和DeleteList.
解：
算法如下:
#defineListSize100//假定表空间大小为100
#include
#include
voidError（char*message）
{
fprintf（stderr,"错误:
%s\n",message）;
exit
（1）;
}//从0开始计，表空间大小应为101了
typedefintDatatype;//假定Datatype的类型为int型
typedefstruct{
Datatypedata[ListSize];//向量data用于存放表结点
intlength;//当前的表长度
}Seqlist;
//以上为定义表结构
//------------以下为要求算法----------
voidInsertList（Seqlist*L,Datatypex,inti）
{
//将新结点x插入L所指的顺序表的第i个结点ai的位置上
intj;
if（i<0||i>L->length）
Error（"positionerror"）;//非法位置，退出
if（L->length>=ListSize）
Error（"overflow"）;
for（j=L->length-1;j>=i;j--）
L->data[j+1]=L->data[j];
L->data[i]=x;
L->length++;
}
voidDeleteList（Seqlist*L,inti）
{//从L所指的顺序表中删除第i个结点ai
intj;
if（i<0||i>L->length-1）
Error（"positionerror"）;
for（j=i+1;jlength;j++）
L->data[j-1]=L->data[j];//结点前移
L->length--;//表长减小
}
//===========以下为验证算法而加=======
voidInitlist（Seqlist*L）
{
L->length=0;
}
voidmain（）
{
Seqlist*SEQA=newSeqlist;
Initlist（SEQA）;
inti;
for（i=0;i{
InsertList（SEQA,i,i）;
printf（"%d\n",SEQA->data[i]）;
}
DeleteList（SEQA,99）;
for（i=0;i{
printf（"%d\n",SEQA->data[i]）;
}}
2.8试分别用顺序表和单链表作为存储结构，实现将线性表（a0,a1,...an-1）就地逆置的操作，所谓"就地"指辅助空间应为O
（1）。
解：
按题意，为将线性表逆置，但辅助空间不能随表的规模增大。
我们分别讨论顺序表和单链表的情况：
1.顺序表：
要将该表逆置，可以将表中的开始结点与终端结点互换，第二个结点与倒数第二个结点互换，如此反复，就可将整个表逆置了。
算法如下：
//表结构定义同上
voidReverseList（Seqlist*L）
{
Datatypet;//设置临时空间用于存放data
inti;
for（i=0;ilength/2;i++）
{t=L->data[i];//交换数据
L->data[i]=L->data[L->length-1-i];
L->data[L->length-1-i]=t;}}
2.链表：
也是可以用交换数据的方式来达到逆置的目的，但是由于是单链表，数据的存取不是随机的，因此算法效率太低，我们可以利用指针的指向转换来达到表逆置的目的。
算法是这样的：
//结构定义略
LinkListReverseList（LinkListhead）
{
//将head所指的单链表逆置
ListNode*p,*q;//设置两个临时指针变量
if（head->next&&head->next->next）
{
//当链表不是空表或单结点时
p=head->next;
q=p->next;
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是递增有序表，所以只要从头找起找到第一个比它大（或相等）的结点数据，把x插入到这个数所在的位置就是了。
算法如下：
voidInsertIncreaseList（Seqlist*L,Datatypex）
{
inti;
for（i=0;ilength&&L->data[i]InsertList（L，x,i）;//调用顺序表插入函数
}
2.10设单链表L是一个递减有序表，试写一算法，将x插入其后仍保持L的有序性。
解：
与上题相类似，只要从头找到第一个比x小（或相等）的结点数据，在这个位置插入就可以了。
算法如下：
LinkListInsertDecreaseList（LinklistL,Datatypex）
{
inti;
ListNode*p,*s;
p=L;
//查找
while（p->next&&p->next->data>x）
p=p->next;
s=（ListNode*）malloc（sizeof（ListNode））;
s->data=x;
s->next=p->next;
p->next=s;
returnL;
}
2.11写一算法在单链表上实现线性表的ListLength（L）运算。
解：
求单链表长只能用遍历的方法了，从头数到尾，总能数出来吧。
算法如下：
intListLength（LinkListL）
{
intlen=0;
ListNode*p;
p=L;//设该表有头结点
while（p->next）
{
p=p->next;
len++;
}
returnlen;}
2.12已知L1和L2分别指向两个单链表的头结点，且已知其长度分别为m和n。
试写一算法将这两个链表连接在一起，请分析你的算法的时间复杂度。
解：
算法如下:
LinkListLink（LinkListL1,LinkListL2）
{
//将两个单链表连接在一起
ListNode*p,*q;
p=L1;
q=L2;
while（p->next）p=p->next;//查找终端结点
p->next=q->next;//将L2的开始结点链接在L1之后
returnL1;}
本算法的主要操作时间花费在查找L1的终端结点上，与L2的长度无关，所以本算的法时间复杂度为：
m+1=O（m）
2.13设A和B是两个单链表，其表中元素递增有序。
试写一算法将A和B归并成一个按元素值递减有序的单链表C，并要求辅助空间为O
（1），请分析算法的时间复杂度。
解：
根据已知条件，A和B是两个递增有序表，所以我们可以以A表为基础，按照插入单个元素的办法把B表的元素插入A表中，完成后，将表逆置就得到了一个按元素值递减有序的单链表C了。
算法如下：
LinkListMergeSort（LinkListA,LinkListB）
{//归并两个递增有序表为一个递减有序表
ListNode*pa,*pb,*qa,*qb;
pa=A;
pb=B;
qa=A->next;
qb=B->next;
while（qa&&qb）
{if（qb->datadata）
{//当B中的元素小于A中当前元素时，插入到它的前面
pb=qb;
qb=qb->next;//指向B中下一元素
pa->next=pb;
pb->next=qa;
pa=pb;}
elseif（qb->data>=pa->data&&qb->data<=qa->data）
{
//当B中元素大于等于A中当前元素
//且小于等于A中后一元素时，
//将此元素插入到A的当前元素之后
pa=qa;
qa=qa->next;//保存A的后一元素位置
pb=qb;
qb=qb->next;//保存B的后一元素位置
pa->next=pb;//插入元素
pb->next=qa;
}
else
{
//如果B中元素总是更大,指针移向下一个A元素
pa=qa;
qa=qa->next;
}
}
if（qb）//如果A表已到终端而B表还有结点未插入
{
//将B表接到A表后面
pa->next=qb;
}
LinkListC=ReverseList（A）;//调用前面2.8题所设计的逆置函数
returnC;//返回新的单链表C,已是递减排列
}
该算法的时间复杂度分析如下：
算法中只有一个while循环，在这个循环中，按照最坏的情况是B元素既有插到A的最前的，也有插到最后的，也就是说需要把A中元素和B中元素全部检查比较过，这时的所费时间就是m+n.而新链表的长度也是m+n+1（有头结点），这样逆置函数的执行所费时间为m+n+1.所以可得整个算法的时间复杂度为：
m+n+m+n+1=2（m+n）+1=O（m+n）
为验证本题设计了一个程序，清单如下：
//ListStruct.h将链表结构存为头文件
typedefcharDataType;//假设结点的数据类型是字符型
typedefstructnode{//结点类型定义
DataTypedata;
structnode*next;//结点的指针域
}ListNode;
typedefListNode*LinkList;
//以下是源文件//在VC++中运行通过。
#include
#include
#include"ListStruct.h"
#include
LinkListCreatList（void）
{//用尾插法建立带头结点的单链表
charch;
LinkListhead=（LinkList）malloc（sizeof（ListNode））;//生成头结点
ListNode*s,*r;
r=head;//尾指针亦指向头结点
while（（ch=getchar（））!
='\n'）
{
s=（ListNode*）malloc（sizeof（ListNode））;
s->data=ch;
r->next=s;
r=s;
}
r->next=NULL;
returnhead;
}
voidOutList（LinkListL）
{
ListNode*p;
p=L;
while（p->next）
{
cout<next->data<<"";
p=p->next;
}
cout<}
LinkListReverseList（LinkListhead）
{
//将head所指的单链表逆置
ListNode*p,*q;//设置两个临时指针变量
if（head->next&&head->next->next）//当链表不是空表或单结点时
{
p=head->next;
q=p->next;
p->next=NULL;//将开始结点变成终端结点
while（q）
{//每次循环将后一个结点变成开始结点
p=q;
q=q->next;
p->next=head->next;
head->next=p;
}
returnhead;
}
returnhead;//直接返回head
}
LinkListMergeSort（LinkListA,LinkListB）
{//归并两个递增有序表为一个递减有序表
ListNode*pa,*pb,*qa,*qb;
pa=A;
pb=B;
qa=A->next;
qb=B->next;
while（qa&&qb）
{
if（qb->datadata）
{
//当B中的元素小于A中当前元素时，插入到它的前面
pb=qb;
qb=qb->next;//指向B中下一元素
pa->next=pb;
pb->next=qa;
pa=pb;}
elseif（qb->data>=pa->data&&qb->data<=qa->data）
{
//当B中元素大于等于A中当前元素
//且小于等于A中后一元素时，
//将此元素插入到A的当前元素之后
pa=qa;
qa=qa->next;//保存A的后一元素位置
pb=qb;
qb=qb->next;//保存B的后一元素位置
pa->next=pb;//插入元素
pb->next=qa;
}
else
{
//如果B中元素总是更大,指针移向下一个A元素
pa=qa;
qa=qa->next;
}
}
if（qb）//如果A表已到终端而B表还有结点未插入
{
//将B表接到A表后面
pa->next=qb;
}
LinkListC=ReverseList（A）;//调用前面2.8题所设计的逆置函数
returnC;//返回新的单链表C,已是递减排列
}
voidmain（）
{
LinkListA,B,C;
A=CreatList（）;
OutList（A）;
B=CreatList（）;
OutList（B）;
C=MergeSort（A,B）;
OutList（C）;
}
以下是一位学友鲁周航提供的算法：
我的算法思路为：
当A、B都不空时，各取A、B表中的第一个结点比较，哪个值小，就把它用头插法插入C表。
（利用原来的头结点，始终是取第一个结点比较）继续取值比较。
当A表为空，或B表为空，则把剩余结点用头插法插入C表。
voidLinkList（Nodetype*A,Nodetype*B,Nodetype**C）
{//假设A和B已建立，C表的头结点已初始化
Nodetype*p,*q;
p=A->Next;
q=B->Next;
while（p&&q）//两表中都有数
{
if（p->DataData）//如A中的结点值大于B中结点值
{
A->Next=p->Next;//A指向A表的下一个结点
p->Next=C->Next;//把P的结点用头插法，插入C表。
C->Next=p;
p=A->Next;//P指向A表的第一个结点，继续比较
}
else
{
B->Next=q->Next;//算理同上面
q->Next=C->Next;
C->Next=q;
q=B->Next;
}
}
if（p）//如A表还有结点，则把剩余结点，用头插法插入C表
{
while（p）
{
A->Next=p->Next;
p->Next=C->Next;
C->Next=p;
p=A->Next;
}
}
else
if（q）//如B表还有结点，则把剩余结点，用头插法插入B表
{
while（q）
{
B->Next=q->Next;
q->Next=C->Next;
C->Next=q;
q=B->Next;
}
}
free（A）;//释放原头结点空间
free（B）;
}
你的算法要排表两次，第一次为插入，第二次为逆序。
2.14已知单链表L是一个递增有序表，试写一高效算法，删除表中值大于min且小于max的结点（若表中有这样的结点），同时释放被删结点的空间，这里min和max是两个给定的参数。
请分析你的算法的时间复杂度。
解：
要解这样的问题，我们首先想到的是拿链表中的元素一个个地与max和min比较，然后删除这个结点，其实因为已知其是有序链表，所以我们只要找到大于min的结点的直接前趋结点，再找到小于max的结点，然后一并把中间的全部摘掉就可以了。
算法如下：
voidDeleteList（LinkListL,DataTypemin,DataTypemax）
{
ListNode*p,*q,*r;
p=L->next;
while（p&&p->data<=min）
{//找比min大的前一个元素位置
q=p;
p=p->next;
}
while（p&&p->data{
r=p;
p=p->next;
free（r）;//释放这个结点空间
}
q->next=p;//把断点链上
}
周鲁航的算法：
voidDeleteList（Nodetype*L,intmin,intmax）
{
Nodetype*p,*q;
if（L->Next==NULL）
{
printf（"空表\n"）;exit（0）;
}
p=L;
while（p->Next!
=NULL）
{//如p的下一个结点值在删除范围内
if（p->Next->Data>min&&p->Next->Data{
q=p->Next;//q指向被删结点
p->Next=q->Next;//从表中摘下被删结点
free（q）;//释放空间
}
else//否则不在范围中。
if（p->Next->Data>max）//如值已经超出范围，则跳出循环，结束删除
break;
else
p=p->Next;//当下一个值小于min时，继续查找。
}}
2.15写一算法将单链表中值重复的结点删除，使所得的结果表中各结点值均不相同。
解：
本题可以这样考虑，先取开始结点中的值，将它与其后的所有结点值一一比较，发现相同的就删除掉，然后再取第二结点的值，重复上述过程直到最后一个结点。
第二种算法是将单链表按值的大小排序，排好后的结点按相同的删除。
以下为周鲁航提供的算法
voidDeleteList（Nodetype*L）
{
Nodetype*p,*q,*s;
if（L->Next==NULL||L->Next==NULL）
{
printf（"删除错误\n"）;exit（0）;
}
p=L->Next;
q=p->Next;
升级会员 