ch2.docx
- 文档编号:26765728
- 上传时间:2023-06-22
- 格式:DOCX
- 页数:29
- 大小:26.32KB
ch2.docx
《ch2.docx》由会员分享,可在线阅读,更多相关《ch2.docx(29页珍藏版)》请在冰豆网上搜索。
ch2
第二章线性表
本章的重点是掌握顺序表和单链表上实现的各种基本算法及相关的时间性能分析,难点是使用本章所学的基本知识设计有效算法解决与线性表相关的应用问题。
要求达到<识记>层次的内容有:
线性表的逻辑结构特征;线性表上定义的基本运算,并利用基本运算构造出较复杂的运算。
要求达到<综合应用>层次的内容有:
顺序表的含义及特点,顺序表上的插入、删除操作及其平均时间性能分析,解决简单应用问题。
链表如何表示线性表中元素之间的逻辑关系;单链表、双链表、循环链表链接方式上的区别;单链表上实现的建表、查找、插入和删除等基本算法及其时间复杂度。
循环链表上尾指针取代头指针的作用,以及单循环链表上的算法与单链表上相应算法的异同点。
双链表的定义和相关算法。
利用链表设计算法解决简单应用问题。
要求达到<领会>层次的内容就是顺序表和链表的比较,以及如何选择其一作为其存储结构才能取得较优的时空性能。
线性表的逻辑结构特征是很容易理解的,如其名,它的逻辑结构特征就好象是一条线,上面打了一个个结,很形象的,如果这条线上面有结,那么它就是非空表,只能有一个开始结点,有且只能有一个终端结点,其它的结前后所相邻的也只能是一个结点(直接前趋和直接后继)。
关于线性表上定义的基本运算,主要有构造空表、求表长、取结点、查找、插入、删除等。
线性表的逻辑结构和存储结构之间的关系。
在计算机中,如何把线性表的结点存放到存储单元中,就有许多方法,最简单的方法就是按顺序存储。
就是按线性表的逻辑结构次序依次存放在一组地址连续的存储单元中。
在存储单元中的各元素的物理位置和逻辑结构中各结点相邻关系是一致的。
在顺序表中实现的基本运算主要讨论了插入和删除两种运算。
相关的算法我们通过练习掌握。
对于顺序表的插入和删除运算,其平均时间复杂度均为O(n)。
线性表的链式存储结构。
它与顺序表不同,链表是用一组任意的存储单元来存放线性表的结点,这组存储单元可以分布在内存中任何位置上。
因此,链表中结点的逻辑次序和物理次序不一定相同。
所以为了能正确表示结点间的逻辑关系,在存储每个结点值的同时,还存储了其后继结点的地址信息(即指针或链)。
这两部分信息组成链表中的结点结构。
一个单链表由头指针的名字来命名。
对于单链表,其操作运算主要有建立单链表(头插法、尾插法和在链表开始结点前附加一个头结点的算法)、查找(按序号和按值)、插入运算、删除运算等。
以上各运算的平均时间复杂度均为O(n).其主要时间是耗费在查找操作上。
循环链表是一种首尾相接的链表。
也就是终端结点的指针域不是指向NULL空而是指向开始结点(也可设置一个头结点),形成一个环。
采用循环链表在实用中多采用尾指针表示单循环链表。
这样做的好处是查找头指针和尾指针的时间都是O
(1),不用遍历整个链表了。
判别链表终止的条件也不同于单链表,它是以指针是否等于某一指定指针如头指针或尾指针来确定。
双链表就是双向链表,就是在单链表的每个结点里再增加一个指向其直接前趋的指针域prior,这样形成的链表就有两条不同方向的链。
使得从已知结点查找其直接前趋结点可以和查找其直接后继结点的时间一样缩短为O
(1)。
双链表一般也由头指针head惟一确定。
双链表也可以头尾相链接构成双(向)循环链表。
关于顺序表和链表的比较,请看下表:
具体要求
顺序表
链表
基于空间
适于线性表长度变化不大,易于事先确定其大小时采用。
适于当线性表长度变化大,难以估计其存储规模时采用。
基于时间
由于顺序表是一种随机存储结构,当线性表的操作主要是查找时,宜采用。
链表中对任何位置进行插入和删除都只需修改指针,所以这类操作为主的线性表宜采用链表做存储结构。
若插入和删除主要发生在表的首尾两端,则宜采用尾指针表示的单循环链表。
第二章线性表
习题及答案
一、基础知识题
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下述算法的功能是什么?
LinkList
Demo(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;
}
returnL;
}//
Demo
答:
该算法的功能是:
将开始结点摘下链接到终端结点之后成为新的终端结点,而原来的第二个结点成为新的开始结点,返回新链表的头指针。
二、算法设计题
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;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;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;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的长度无关,所以本算的法时间复杂度为: 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->data { //当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< 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->data { //当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;//返回新的单链
- 配套讲稿:
如PPT文件的首页显示word图标,表示该PPT已包含配套word讲稿。双击word图标可打开word文档。
- 特殊限制:
部分文档作品中含有的国旗、国徽等图片,仅作为作品整体效果示例展示,禁止商用。设计者仅对作品中独创性部分享有著作权。
- 关 键 词:
- ch2