第2章线性表A-2(2-25本)

合集下载

DS02线性表习题参考解答

DS02线性表习题参考解答

第2章线性表习题参考解答一、简答题1.试描述头指针、头结点、开始结点的区别、并说明头指针和头结点的作用。

【答】头指针:是指向链表中的第一个结点的指针。

头结点:在开始结点之前附加上的一个结点。

开始结点:链表的第一个结点。

头指针是一个指向地址的变量,用于表示一个链表的开始。

引入头结点可以更加方便的进行链表是否为空的判断,同时方便了插入和删除结点。

开始结点用于存储链表的第一个数据元素。

2.何时选用顺序表、何时选用链表作为线性表的存储结构为宜?【答】顺序表中查找元素、获取表长非常容易,但是,要插入或者删除一个元素却需要移动大量的元素;相反,链表中却是方便插入或者删除元素,在查找元素的是,需要进行遍历。

因此,当所涉及的问题常常进行查找等操作,而插入、删除相对较少的是,适合采用顺序表;当常常需要插入、删除的时候,适合采用链表。

3.为什么在单循环链表中设置尾指针比设置头指针更好?【答】在单循环链表中,设置尾指针,可以更方便的判断链表是否为空。

4.在单链表、双链表和单循环链表中,若仅知道指针p指向某结点,不知道头指针,能否将结点*p从相应的链表中删去?【答】本题分三种情况讨论:1、单链表:当知道指针p指向某结点时,能够根据该指针找到其直接后继,但是不知道头指针,因此不能找到该结点的直接前趋,因此,无法删除该结点。

2、双链表:根据指针p可以找到该结点的直接前趋和直接后继,因此,能够删除该结点。

3、单循环链表:和双链表类似,根据指针p也可以找到该结点的直接前趋和直接后继,因此,也可以删除该结点。

5.下述算法的功能是什么?LinkList Demo(LinkList *L) /* L是无头结点单链表*/{LNode *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;}return L;} /* Demo */【答】将原来的第一个结点变成末尾结点,原来的第二个结点变成链表的第一个结点。

最新版《数据结构》各章习题及答案

最新版《数据结构》各章习题及答案

最新版《数据结构》各章习题及答案第一章绪论一、选择题1.组成数据的基本单位是()(A)数据项(B)数据类型(C)数据元素(D)数据变量2.数据结构是研究数据的()以及它们之间的相互关系。

(A)理想结构,物理结构(B)理想结构,抽象结构(C)物理结构,逻辑结构(D)抽象结构,逻辑结构3.在数据结构中,从逻辑上可以把数据结构分成()(A)动态结构和静态结构(B)紧凑结构和非紧凑结构(C)线性结构和非线性结构(D)内部结构和外部结构4.数据结构是一门研究非数值计算的程序设计问题中计算机的(①)以及它们之间的(②)和运算等的学科。

① (A)数据元素(B)计算方法(C)逻辑存储(D)数据映像② (A)结构(B)关系(C)运算(D)算法5.算法分析的目的是()。

(A)找出数据结构的合理性(B)研究算法中的输入和输出的关系(C)分析算法的效率以求改进(D)分析算法的易懂性和文档性6.计算机算法指的是(①),它必须具备输入、输出和(②)等5 个特性。

① (A)计算方法(B)排序方法(C)解决问题的有限运算序列(D)调度方法② (A)可执行性、可移植性和可扩充性(B)可行性、确定性和有穷性(C)确定性、有穷性和稳定性(D)易读性、稳定性和安全性二、判断题1.数据的机内表示称为数据的存储结构。

()2.算法就是程序。

()3.数据元素是数据的最小单位。

()4.算法的五个特性为:有穷性、输入、输出、完成性和确定性。

()5.算法的时间复杂度取决于问题的规模和待处理数据的初态。

()三、填空题1.数据逻辑结构包括________、________、_________ 和__________ 四种类型,其中树形结构和图形结构合称为_____ 。

2.在线性结构中,第一个结点____前驱结点,其余每个结点有且只有______ 个前驱结点;最后一个结点______后续结点,其余每个结点有且只有 _______ 个后续结点。

3.在树形结构中,树根结点没有_______ 结点,其余每个结点有且只有_______个前驱结点;叶子结点没有 ________ 结点,其余每个结点的后续结点可以_________。

清华大学严蔚敏数据结构习题集(C版)答案

清华大学严蔚敏数据结构习题集(C版)答案

清华大学严蔚敏数据结构习题集(C版)答案清华大学严蔚敏数据结构习题集(C版)答案第一章绪论1.16void print_descending(int x,int y,int z)//按从大到小顺序输出三个数{scanf("%d,%d,%d",&x,&y,&z);if(x<y) x<->y; //<->为表示交换的双目运算符,以下同if(y<z) y<->z;if(x<y) x<->y; //冒泡排序printf("%d %d %d",x,y,z);}//print_descending1.17Status fib(int k,int m,int &f)//求k阶斐波那契序列的第m项的值f {int tempd;if(k<2||m<0) return ERROR;if(m<k-1) f=0;else if (m==k-1) f=1;else{for(i=0;i<=k-2;i++) temp=0;temp[k-1]=1; //初始化for(i=k;i<=m;i++) //求出序列第k至第m个元素的值{sum=0;for(j=i-k;j<i;j++) sum+=temp[j];temp=sum;}f=temp[m];}return OK;}//fib分析:通过保存已经计算出来的结果,此方法的时间复杂度仅为O(m^2).如果采用递归编程(大多数人都会首先想到递归方法),则时间复杂度将高达O(k^m).1.18typedef struct{char *sport;enum{male,female} gender;char schoolname; //校名为'A','B','C','D'或'E'char *result;int score;} resulttype;typedef struct{int malescore;int femalescore;int totalscore;} scoretype;void summary(resulttype result[ ])//求各校的男女总分和团体总分,假设结果已经储存在result[ ]数组中{scoretype score;i=0;while(result.sport!=NULL){switch(result.schoolname){case 'A':score[ 0 ].totalscore+=result.score;if(result.gender==0) score[ 0 ].malescore+=result.score; else score[ 0 ].femalescore+=result.score;break;case 'B':score.totalscore+=result.score;if(result.gender==0) score.malescore+=result.score;else score.femalescore+=result.score;break;………………}i++;}for(i=0;i<5;i++){printf("School %d:\n",i);printf("Total score of male:%d\n",score.malescore);printf("Total score of female:%d\n",score.femalescore);printf("Total score of all:%d\n\n",score.totalscore);}}//summary1.19Status algo119(int a[ARRSIZE])//求i!*2^i序列的值且不超过maxint {last=1;for(i=1;i<=ARRSIZE;i++){a[i-1]=last*2*i;if((a[i-1]/last)!=(2*i)) reurn OVERFLOW;last=a[i-1];return OK;}}//algo119分析:当某一项的结果超过了maxint时,它除以前面一项的商会发生异常.1.20void polyvalue(){float ad;float *p=a;printf("Input number of terms:");scanf("%d",&n);printf("Input the %d coefficients from a0 to a%d:\n",n,n);for(i=0;i<=n;i++) scanf("%f",p++);printf("Input value of x:");scanf("%f",&x);p=a;xp=1;sum=0; //xp用于存放x的i次方for(i=0;i<=n;i++){sum+=xp*(*p++);xp*=x;}printf("Value is:%f",sum);}//polyvalue第二章线性表2.10Status DeleteK(SqList &a,int i,int k)//删除线性表a中第i个元素起的k个元素{if(i<1||k<0||i+k-1>a.length) return INFEASIBLE;for(count=1;i+count-1<=a.length-k;count++) //注意循环结束的条件 a.elem[i+count-1]=a.elem[i+count+k-1];a.length-=k;return OK;}//DeleteK2.11Status Insert_SqList(SqList &va,int x)//把x插入递增有序表va中{if(va.length+1>va.listsize) return ERROR;va.length++;for(i=va.length-1;va.elem>x&&i>=0;i--)va.elem[i+1]=va.elem;va.elem[i+1]=x;return OK;}//Insert_SqList2.12int ListComp(SqList A,SqList B)//比较字符表A和B,并用返回值表示结果,值为正,表示A>B;值为负,表示A<B;值为零,表示A=B{for(i=1;A.elem||B.elem;i++)if(A.elem!=B.elem) return A.elem-B.elem;return 0;}//ListComp2.13LNode* Locate(LinkList L,int x)//链表上的元素查找,返回指针{for(p=l->next;p&&p->data!=x;p=p->next);return p;}//Locate2.14int Length(LinkList L)//求链表的长度{for(k=0,p=L;p->next;p=p->next,k++);return k;}//Length2.15void ListConcat(LinkList ha,LinkList hb,LinkList &hc)//把链表hb 接在ha后面形成链表hc{hc=ha;p=ha;while(p->next) p=p->next;p->next=hb;}//ListConcat2.16见书后答案.2.17Status Insert(LinkList &L,int i,int b)//在无头结点链表L的第i个元素之前插入元素b{p=L;q=(LinkList*)malloc(sizeof(LNode));q.data=b;if(i==1){q.next=p;L=q; //插入在链表头部}{while(--i>1) p=p->next;q->next=p->next;p->next=q; //插入在第i个元素的位置}}//Insert2.18Status Delete(LinkList &L,int i)//在无头结点链表L中删除第i个元素{if(i==1) L=L->next; //删除第一个元素else{p=L;while(--i>1) p=p->next;p->next=p->next->next; //删除第i个元素}}//Delete2.19Status Delete_Between(Linklist &L,int mink,int maxk)//删除元素递增排列的链表L中值大于mink且小于maxk的所有元素{while(p->next->data<=mink) p=p->next; //p是最后一个不大于mink 的元素if(p->next) //如果还有比mink更大的元素{q=p->next;while(q->data<maxk) q=q->next; //q是第一个不小于maxk的元素 p->next=q;}}//Delete_Between2.20Status Delete_Equal(Linklist &L)//删除元素递增排列的链表L中所有值相同的元素{p=L->next;q=p->next; //p,q指向相邻两元素while(p->next){if(p->data!=q->data){p=p->next;q=p->next; //当相邻两元素不相等时,p,q都向后推一步 }else{while(q->data==p->data){free(q);q=q->next;}p->next=q;p=q;q=p->next; //当相邻元素相等时删除多余元素}//else}//while}//Delete_Equal2.21void reverse(SqList &A)//顺序表的就地逆置{for(i=1,j=A.length;i<j;i++,j--)A.elem<->A.elem[j];}//reverse2.22void LinkList_reverse(Linklist &L)//链表的就地逆置;为简化算法,假设表长大于2{p=L->next;q=p->next;s=q->next;p->next=NULL;while(s->next){q->next=p;p=q;q=s;s=s->next; //把L的元素逐个插入新表表头}q->next=p;s->next=q;L->next=s;}//LinkList_reverse分析:本算法的思想是,逐个地把L的当前元素q插入新的链表头部,p为新表表头.2.23void merge1(LinkList &A,LinkList &B,LinkList &C)//把链表A和B合并为C,A和B的元素间隔排列,且使用原存储空间{p=A->next;q=B->next;C=A;while(p&&q){s=p->next;p->next=q; //将B的元素插入if(s){t=q->next;q->next=s; //如A非空,将A的元素插入}p=s;q=t;}//while}//merge12.24void reverse_merge(LinkList &A,LinkList &B,LinkList &C)//把元素递增排列的链表A和B合并为C,且C中元素递减排列,使用原空间{pa=A->next;pb=B->next;pre=NULL; //pa和pb分别指向A,B的当前元素 while(pa||pb){if(pa->data<pb->data||!pb){pc=pa;q=pa->next;pa->next=pre;pa=q; //将A的元素插入新表}else{pc=pb;q=pb->next;pb->next=pre;pb=q; //将B的元素插入新表}pre=pc;}C=A;A->next=pc; //构造新表头}//reverse_merge分析:本算法的思想是,按从小到大的顺序依次把A和B的元素插入新表的头部pc处,最后处理A或B的剩余元素.2.25void SqList_Intersect(SqList A,SqList B,SqList &C)//求元素递增排列的线性表A和B的元素的交集并存入C中{i=1;j=1;k=0;while(A.elem&&B.elem[j]){if(A.elem<B.elem[j]) i++;if(A.elem>B.elem[j]) j++;if(A.elem==B.elem[j]){C.elem[++k]=A.elem; //当发现了一个在A,B中都存在的元素, i++;j++; //就添加到C中}}//while}//SqList_Intersect2.26void LinkList_Intersect(LinkList A,LinkList B,LinkList &C)//在链表结构上重做上题{p=A->next;q=B->next;pc=(LNode*)malloc(sizeof(LNode));while(p&&q){if(p->data<q->data) p=p->next;else if(p->data>q->data) q=q->next;else{s=(LNode*)malloc(sizeof(LNode));s->data=p->data;pc->next=s;pc=s;p=p->next;q=q->next;}}//whileC=pc;}//LinkList_Intersect2.27void SqList_Intersect_True(SqList &A,SqList B)//求元素递增排列的线性表A和B的元素的交集并存回A中{i=1;j=1;k=0;while(A.elem&&B.elem[j]){if(A.elem<B.elem[j]) i++;else if(A.elem>B.elem[j]) j++;else if(A.elem!=A.elem[k]){A.elem[++k]=A.elem; //当发现了一个在A,B中都存在的元素i++;j++; //且C中没有,就添加到C中}}//whilewhile(A.elem[k]) A.elem[k++]=0;}//SqList_Intersect_True2.28void LinkList_Intersect_True(LinkList &A,LinkList B)//在链表结构上重做上题{p=A->next;q=B->next;pc=A;while(p&&q){if(p->data<q->data) p=p->next;else if(p->data>q->data) q=q->next;else if(p->data!=pc->data){pc=pc->next;pc->data=p->data;p=p->next;q=q->next;}}//while}//LinkList_Intersect_True2.29void SqList_Intersect_Delete(SqList &A,SqList B,SqList C){i=0;j=0;k=0;m=0; //i指示A中元素原来的位置,m为移动后的位置 while(i<A.length&&j<B.length&& k<C.length){if(B.elem[j]<C.elem[k]) j++;else if(B.elem[j]>C.elem[k]) k++;else{same=B.elem[j]; //找到了相同元素same while(B.elem[j]==same) j++;while(C.elem[k]==same) k++; //j,k后移到新的元素while(i<A.length&&A.elem<same)A.elem[m++]=A.elem[i++]; //需保留的元素移动到新位置while(i<A.length&&A.elem==same) i++; //跳过相同的元素}}//whilewhile(i<A.length)A.elem[m++]=A.elem[i++]; //A的剩余元素重新存储。

第2章线性表A-2

第2章线性表A-2
1.读取元素操作 GetElem (L,i, &e) 2.插入元素操作 ListInsert (&L, i, e) 3.删除元素操作 ListDelete (&L, i, &e) 4.单链表的建立和输出 5.链表的归并 6 其它链表形式
16
1 读取元素操作
单链表中想取得第i个元素,必须从头指针出发 寻找,不能随机存取 。 Status GetElem_L(LinkList L, int i, ElemType &e) { P=L->next; j=1; //p指向第一个结点,j为计数器 while(p&&j<i) { p=p->next; ++j;} if(!p||j>i) return ERROR; e=p->data; return OK; }
5
例: 一个线性表的逻辑结构为:
(ZHAO,QIAN,SUN,LI,ZHOU,WU,ZHENG,WANG),其存 储结构用单链表表示如下,请问其头指针的值是多少?
答:头指针是指向 链表中第一个结点 的指针,因此关键 是要寻找第一个结 点的地址。 H
31
ZHAO 7
∴头指针的值是31
存储地址 1 7 13 19 25 31 37 43
20
3.删除元素操作
在链表中删除某元素的示意图如下:
p a
× b
×
c
p->next
(p->next) -> next
删除步骤(即核心语句): q = p->next; //保存b的指针,靠它才能指向c p->next=q->next; //a、c两结点相连 free(q) ; //删除b结点,彻底释放

数据结构-数据结构题库

数据结构-数据结构题库

第一章绪论一.单项选择题1.数据对象是指______。

A. 描述客观事物且由计算机处理的数值、字符等符号的总称B. 数据的基本单位C. 性质相同的数据元素的集合D. 相互之间存在一种或多种特定关系的数据元素的集合2.在数据结构中,数据的基本单位是_________。

A. 数据项B. 数据类型C. 数据元素D. 数据变量3.数据结构中数据元素之间的逻辑关系被称为______。

A. 数据的存储结构B. 数据的基本操作C. 程序的算法D. 数据的逻辑结构4.在数据结构中,与所使用计算机无关的是数据的_______。

A. 存储结构B. 逻辑和物理结构C. 逻辑结构D. 物理结构5.在链式存储结构中,数据之间的关系是通过________体现的。

A. 数据在内存的相对位置B. 指示数据元素的指针C. 数据的存储地址D. 指针6.在定义ADT时,除数据对象和数据关系外,还需说明_______。

A. 数据元素B. 算法C. 基本操作D. 数据项7.计算算法的时间复杂度是属于一种_______。

A. 事前统计的方法B. 事前分析估算的方法C. 事后统计的方法D. 事后分析估算的方法8.在对算法的时间复杂度进行估计的时候,下列最佳的时间复杂度是_______。

A. n2B. nlognC. nD. logn9.设使用某算法对n个元素进行处理,所需的时间是T(n)=100nlog2n+200n+2000,则该算法的渐近时间复杂度为_______。

A. O(1)B. O(n)C. O(200n)D. O(nlog2n)10.有如下递归函数fact(a),其时间复杂度为_________。

int fact(int a){if(n==0)retrun 1;elsereturn(n*fact(n-1));}A. O(n)B. O(n2)C. O(n3)D. O(n4)11.线性表若采用链式存储结构时,要求内存中可用存储单元的地址_______。

DS第二章_课后习题答案

DS第二章_课后习题答案

第二章线性表2.1 填空题(1)一半插入或删除的位置(2)静态动态(3)一定不一定(4)头指针头结点的next 前一个元素的next2.2 选择题(1)A (2) DA GKHDA EL IAF IFA(IDA)(3)D (4)D (5) D2.3头指针:在带头结点的链表中,头指针存储头结点的地址;在不带头结点的链表中,头指针存放第一个元素结点的地址;头结点:为了操作方便,在第一个元素结点前申请一个结点,其指针域存放第一个元素结点的地址,数据域可以什么都不放;首元素结点:第一个元素的结点。

2.4已知顺序表L递增有序,写一算法,将X插入到线性表的适当位置上,以保持线性表的有序性。

void InserList(SeqList *L,ElemType x){int i=L->last;if(L->last>=MAXSIZE-1) return FALSE; //顺序表已满while(i>=0 && L->elem[i]>x){L->elem[i+1]=L->elem[i];i--;}L->elem[i+1]=x;L->last++;}2.5 删除顺序表中从i开始的k个元素int DelList(SeqList *L,int i,int k){int j,l;if(i<=0||i>L->last) {printf("The Initial Position is Error!"); return 0;}if(k<=0) return 1; /*No Need to Delete*/if(i+k-2>=L->last) L->last=L->last-k; /*modify the length*/for(j=i-1,l=i+k-1;l<L->last;j++,l++)L->elem[j]=L->elem[l];L->last=L->last-k;return 1;}2.6 已知长度为n的线性表A采用顺序存储结构,请写一时间复杂度为O(n)、空间复杂度为O(1)的算法,删除线性表中所有值为item的数据元素。

第二章线性表

第二章线性表

第二章线性表第二章线性表一、选择题1.线性表是具有n个__C___的有限序列(n>0)。

A.表元素B.字符C.数据元素D.数据项2.一个顺序表所占用的存储空间大小与___B___无关。

A.表的长度C.元素的类型B.元素的存放顺序D.元素中各字段的类型3.线性表的顺序存储结构是一种__A___。

A.随机存取的存储方式C.索引存取的存储方式B.顺序存取的存储方式D.Hash存取的存储方式4. 若线性表采用顺序存储结构,每个元素占用4 个存储单元,第一个元素的存储地址为100,则第12 个元素的存储地址是__B____。

A.112 B.144 C.148 D.4125. 线性表是__A____。

A.一个有限序列,可以为空B.一个有限序列,不能为空C.一个无限序列,可以为空D.一个无限序列,不能为空6.对于顺序存储的线性表,访问结点和增加、删除结点的时间复杂度为__C____。

A.O(n)O(n)B.O(n)O(1)C.O(1)O(n)D.O(1)O(1) 7.若长度为n的非空线性表采用顺序存储结构,删除表的第i个数据元素,首先需要移动表中___A____中数据元素。

A.n-i B.n+i C.n-i+1 D.n-i-1 8.对顺序存储的线性表,设其长度为n,在任何位置插入或删除操作都是等概率的。

删除一个元素时平均要移动表中的____C____个元素。

A.n/2 B.(n+1)/2 C.(n-1)/2 D.n 9.若长度为n的线性表采用顺序存储结构,在其第i个位置插入一个新元素的算法的时间复杂度为__C____。

(1≤i≤n+1)A.O(0)B.O(1)C.O(n)D.O(n2)10.线性表中各链接点之间的地址___C____。

A.必须连续B.部分地址必须连续C.不一定连续D.连续与否无所谓11.在n个结点的线性表的数组表示中,算法的时间复杂度是O(1)的操作是_A______。

A.访问第i个结点后插入一个新结点(1≤i≤n)和求第i个结点的直接前驱(2≤i≤n)B.在第i个结点后插入一个新结点(1≤i≤n)C.删除第i 个结点(1≤i≤n)D.以上都不对12.单链表中,增加一个头结点的目的是为了____C_____。

数据结构复习题目及答案

数据结构复习题目及答案

《数据结构-C语言版》第一章绪论单项选择题1.在数据结构中,数据的基本单位是_________。

A.数据项B.数据类型C.数据元素D.数据变量2.数据结构中数据元素之间的逻辑关系被称为______。

A.数据的存储结构B.数据的基本操作C.程序的算法D.数据的逻辑结构3.在数据结构中,与所使用计算机无关的是数据的_______。

A.存储结构B.逻辑和物理结构C.逻辑结构D.物理结构4.在链式存储结构中,数据之间的关系是通过________体现的。

A.数据在内存的相对位置B.指示数据元素的指针C.数据的存储地址D.指针5.计算算法的时间复杂度是属于一种_______。

A.事前统计的方法B.事前分析估算的方法C.事后统计的方法D.事后分析估算的方法6.在对算法的时间复杂度进行估计的时候,下列最佳的时间复杂度是______。

2A.nB.nlognC.nD.logn7.设使用某算法对n个元素进行处理,所需的时间是T(n)=100nlog2n+200n+2000,则该算法的渐近时间复杂度为_______。

A.O(1)B.O(n)C.O(200n)D.O(nlog2n)1CDCBBDD第二章线性表单项选择题1.链表不具有的特点是________。

A.可随机访问任一元素B.插入和删除时不需要移动元素C.不必事先估计存储空间D.所需空间与线性表的长度正比2.设顺序表的每个元素占8个存储单元。

第1个单元的存储地址是100,则第6个元素占用的最后一个存储单元的地址为。

A.139B.140C.147D.1483.在线性链表存储结构下,插入操作算法。

A.需要判断是否表满B.需要判断是否表空C.不需要判断表满D.需要判断是否表空和表满4.在一个单链表中,若删除p所指结点的后继结点,则执行。

A.p->next=p->next->next;B.p->next=p->next;C.p=p->next->next;D.p=p->next;p->next=p->next->next;5.将长度为 n的单链表接在长度为m的单链表之后的算法时间复杂度为。

数据结构线性表课后答案

数据结构线性表课后答案

第2章线性表1.选择题(1)顺序表中第一个元素的存储地址是100,每个元素的长度为2,则第5个元素的地址是()。

A.110 B.108 C.100 D.120答案:B解释:顺序表中的数据连续存储,所以第5个元素的地址为:100+2*4=108。

(2)在n个结点的顺序表中,算法的时间复杂度是O(1)的操作是()。

A.访问第i个结点(1≤i≤n)和求第i个结点的直接前驱(2≤i≤n)B.在第i个结点后插入一个新结点(1≤i≤n)C.删除第i个结点(1≤i≤n)D.将n个结点从小到大排序答案:A解释:在顺序表中插入一个结点的时间复杂度都是O(n2),排序的时间复杂度为O(n2)或O(nlog2n)。

顺序表是一种随机存取结构,访问第i个结点和求第i个结点的直接前驱都可以直接通过数组的下标直接定位,时间复杂度是O(1)。

(3)向一个有127个元素的顺序表中插入一个新元素并保持原来顺序不变,平均要移动的元素个数为()。

A.8 B.63.5 C.63 D.7答案:B解释:平均要移动的元素个数为:n/2。

(4)链接存储的存储结构所占存储空间()。

A.分两部分,一部分存放结点值,另一部分存放表示结点间关系的指针B.只有一部分,存放结点值C.只有一部分,存储表示结点间关系的指针D.分两部分,一部分存放结点值,另一部分存放结点所占单元数答案:A(5)线性表若采用链式存储结构时,要求内存中可用存储单元的地址()。

A.必须是连续的B.部分地址必须是连续的C.一定是不连续的D.连续或不连续都可以答案:D(6)线性表L在()情况下适用于使用链式结构实现。

A.需经常修改L中的结点值B.需不断对L进行删除插入C.L中含有大量的结点D.L中结点结构复杂答案:B解释:链表最大的优点在于插入和删除时不需要移动数据,直接修改指针即可。

(7)单链表的存储密度()。

A.大于1 B.等于1 C.小于1 D.不能确定答案:C解释:存储密度是指一个结点数据本身所占的存储空间和整个结点所占的存储空间之比,假设单链表一个结点本身所占的空间为D,指针域所占的空间为N,则存储密度为:D/(D+N),一定小于1。

数据结构--线性表习题及答案

数据结构--线性表习题及答案

数据结构--线性表习题及答案第⼆章线性表⼀、选择题1、若长度为n的线性表采⽤顺序存储结构,在其第i个位置插⼊⼀个新元素算法的时间复杂度()。

A. O(log2n)B.O(1)C. O(n)D.O(n2)2、若⼀个线性表中最常⽤的操作是取第i个元素和找第i个元素的前趋元素,则采⽤()存储⽅式最节省时间。

A. 顺序表B. 单链表C. 双链表D. 单循环链表3、具有线性结构的数据结构是()。

A. 图B. 树C. ⼴义表D.栈4、在⼀个长度为n的顺序表中,在第i个元素之前插⼊⼀个新元素时,需向后移动()个元素。

A. n-iB. n-i+1C. n-i-1D. i5、⾮空的循环单链表head的尾结点p满⾜()。

A. p->next==headB. p->next==NULLC. p==NULLD. p==head6、链表不具有的特点是()。

A. 可随机访问任⼀元素B. 插⼊删除不需要移动元素C. 不必事先估计存储空间D. 所需空间与线性表长度成正⽐7、在双向循环链表中,在p指针所指的结点后插⼊⼀个指针q所指向的新结点,修改指针的操作是()。

A. p->next=q;q->prior=p;p->next->prior=q;q->next=q;B. p->next=q;p->next->prior=q;q->prior=p;q->next=p->next;C. q->prior=p;q->next=p->next;p->next->prior=q;p->next=q;D. q->next=p->next;q->prior=p;p->next=q;p->next=q;8、线性表采⽤链式存储时,结点的存储地址()。

A. 必须是连续的B. 必须是不连续的C. 连续与否均可D. 和头结点的存储地址相连续9、在⼀个长度为n的顺序表中删除第i个元素,需要向前移动()个元素。

南邮数据结构答案

南邮数据结构答案

第1 章绪论一、基础题1. A2. C3. C4. A5. C二、扩展题1.数据是计算机加工处理的对象;数据元素是数据的基本单位,在计算机程序中通常作为一个整体进行考虑和处理;数据项是组成数据元素的、不可分割的最小单位。

2.数据结构是按某种逻辑关系组织起来的数据元素的集合,使用计算机语言描述并按一定的存储方式存储在计算机中,并在其上定义了一组运算。

3.集合结构、线性结构、树形结构和图形结构。

集合结构中,元素之间没有关系;线性结构中,元素之间存在一对一的关系;树形结构中,元素之间存在一对多的关系,其中最多只有一个元素没有前驱元素,这个元素就是根;图形结构中,元素之间存在多对多的关系。

4.顺序存储、链式存储、索引存储和散列存储。

5.一个算法是对特定问题的求解步骤的一种描述,是指令的有限序列。

其特征包括:➢输入:算法有零个或多个输入➢输出:算法至少产生一个输出➢确定性:算法的每一条指令都有确切的定义,没有二义性。

➢能行性/可行性:可以通过已经实现的基本运算执行有限次来实现➢有穷性:算法必须总能在执行有限步之后终止6.联系:程序是计算机指令的有序集合,是算法用某种程序设计语言的表述,是算法在计算机上的具体实现。

区别:在语言描述上不同,程序必须是用规定的程序设计语言来写,而算法的描述形式包括自然语言、伪代码、流程图和程序语言等;算法所描述的步骤一定是有限的,而程序可以无限地执行下去,比如一个死循环可以称为程序,但不能称为算法。

7.正确性:算法的执行结果应当满足功能需求,无语法错误,无逻辑错误简明性:思路清晰、层次分明、易读易懂,有利于调试维护健壮性:当输入不合法数据时,应能做适当处理,不至于引起严重后果效率:有效使用存储空间和有高的时间效率最优性:解决同一个问题可能有多种算法,应进行比较,选择最佳算法可使用性:用户友好性8(1)执行次数为n-1(n>=2),n=1时执行1次;时间复杂度为O(n)。

(2)执行次数为⌈log3n⌉;时间复杂度为O(logn)(3) 执行次数为n2;时间复杂度为O(n2)(4)执行次数为⌊√n⌋ + 1;时间复杂度为O(√n)第2 章线性表1.A2.D3.B4.C5.B6.D7.D8.C9.A10.D1.编写程序实现对顺序表逆置。

第二章线性表答案

第二章线性表答案

第⼆章线性表答案第2章线性表⼀选择题1.下述哪⼀条是顺序存储结构的优点?( A )A.存储密度⼤ B.插⼊运算⽅便 C.删除运算⽅便 D.可⽅便地⽤于各种逻辑结构的存储表⽰2.下⾯关于线性表的叙述中,错误的是哪⼀个?( B )A.线性表采⽤顺序存储,必须占⽤⼀⽚连续的存储单元。

B.线性表采⽤顺序存储,便于进⾏插⼊和删除操作。

C.线性表采⽤链接存储,不必占⽤⼀⽚连续的存储单元。

D.线性表采⽤链接存储,便于插⼊和删除操作。

3.线性表是具有n个( C )的有限序列(n>0)。

A.表元素 B.字符 C.数据元素 D.数据项 E.信息项4.若某线性表最常⽤的操作是存取任⼀指定序号的元素和在最后进⾏插⼊和删除运算,则利⽤( A )存储⽅式最节省时间。

A.顺序表 B.双链表 C.带头结点的双循环链表 D.单循环链表5.某线性表中最常⽤的操作是在最后⼀个元素之后插⼊⼀个元素和删除第⼀个元素,则采⽤( D )存储⽅式最节省运算时间。

A.单链表 B.仅有头指针的单循环链表 C.双链表D.仅有尾指针的单循环链表6.设⼀个链表最常⽤的操作是在末尾插⼊结点和删除尾结点,则选⽤( D )最节省时间。

A. 单链表B.单循环链表C. 带尾指针的单循环链表D.带头结点的双循环链表7.若某表最常⽤的操作是在最后⼀个结点之后插⼊⼀个结点或删除最后⼀个结点。

则采⽤( D )存储⽅式最节省运算时间。

A.单链表 B.双链表 C.单循环链表 D.带头结点的双循环链表8. 静态链表中指针表⽰的是( BC ).A.内存地址 B.数组下标 C.下⼀元素地址D.左、右孩⼦地址9. 链表不具有的特点是( C )A.插⼊、删除不需要移动元素 B.可随机访问任⼀元素C.不必事先估计存储空间 D.所需空间与线性长度成正⽐10. 下⾯的叙述不正确的是( BC )A.线性表在链式存储时,查找第i个元素的时间同i的值成正⽐表4s→供选择的答案:A.连续B.单向链接C.双向链接D.不连接E.循环链接F.树状G.⽹状H.随机I.顺序J.顺序循环12.(1) 静态链表既有顺序存储的优点,⼜有动态链表的优点。

DSFA第2章

DSFA第2章

14
template<class T> bool SeqList<T>::Find(int i,T& x) const { if (i<0 || i>n-1) { cout<<"Out of Bounds"<<endl; return false; } x=elements[i]; return true; } 渐近时间复杂度:O(1)
渐近时间复杂度:O(n)
18
nHale Waihona Puke 1(3)删除操作 Delete(i): 删除元素ai。 删除它
前移n-i-1个元素
a0
0
… ai-1 ai ai+1 … … an-1 … …
… i-1 i i+1 i+2 … 删除操作 n-1 … maxLength-1
19
删除操作算法: template <class T> bool SeqList<T>::Delete(int i) { if ( !n ) { cout<<"UnderFlow"<<endl; return false; } if ( i<0 || i>n-1 ) { cout<<"Out Of Bounds"<<endl; return false; } for (int j=i+1;j<n;j++) elements[j-1]=elements[j]; n--; return true; }
4. 动态一维数组描述顺序表
class SeqList:public LinearList<T> { public: SeqList(int mSize); …… private: int maxLength; T *elements; //动态一维数组的指针 }

第二章 线性表

第二章 线性表

第二章线性表1. 下面关于线性表的叙述错误的是()。

A.线性表采用顺序存储必须占用一片连续的存储空间B. 线性表采用链式存储不必占用一片连续的存储空间 C. 线性表采用链式存储便于插入和删除操作的实现 D. 线性表采用顺序存储便于插入和删除操作的实现 2. 设指针变量p指向单链表中结点A,若删除单链表中结点A,则需要修改指针的操作序列为()。

A.q=p->next;p->data=q->data;p->next=q->next;free(q);B. q=p->next;q->data=p->data;p->next=q->next;free(q); C. q=p->next;p->next=q->next;free(q); D. q=p->next;p->data=q->data;free(q);3. 设一维数组中有n个数组元素,则读取第i个数组元素的平均时间复杂度为()。

A. O(n)B. O(nlog2n)C. O(1)D. O(n2)4.设一个有序的单链表中有n个结点,现要求插入一个新结点后使得单链表仍然保持有序,则该操作的时间复杂度为()。

2A. O(log2n)B. O(1)C. O(n)D. O(n)5.设一条单链表的头指针变量为head且该链表没有头结点,则其判空条件是()。

A. head==0B.head->next==0C. head->next==headD.head!=06.设带有头结点的单向循环链表的头指针变量为head,则其判空条件是()。

A. head==0 B. head->next==0 C. head->next==head D. head!=07.建立一个长度为n的有序单链表的时间复杂度为() A. O(n) B. O(1) C. O(n2) D. O(log2n)8.设顺序线性表中有n个数据元素,则删除表中第i个元素需要移动()个元素。

数据结构第二章线性表1答案

数据结构第二章线性表1答案

数据结构第二章线性表1答案第二部分线性表一、选择题1.关于顺序存储的叙述中,哪一条是不正确的( B )A.存储密度大B.逻辑上相邻的结点物理上不必邻接C.可以通过计算直接确定第i个结点的位置D.插入、删除操作不方便2.长度为n的单链表连接在长度为m的单链表后的算法的时间复杂度为( C )A O(n)B O(1)C O(m)D O(m+n)3.在n个结点的顺序表中,算法的时间复杂度是O(1)的操作是:( A )A 访问第i个结点(1<=i<=n)和求第i个结点的直接前趋(2<=i<=n)B 在第i个结点(1<=i<=n)后插入一个新结点C 删除第i个结点(1<=i<=n)D 将n个结点从小到大排序4.一个向量第一个元素的存储地址是100 ,每个元素的长度为2 ,则第5 个元素的地址是:( B )(A )110 ( B )108 (C )100 (D )1205.已知一个顺序存储的线性表,设每个结点需要占m个存储单元,若第一个结点的地址为da,则第i个结点的地址为:( A ) A)da+(i-1)*m B) da+i*m C) da-i*m D) da+(i+1)*m6.在具有n个结点的单链表中,实现(A )的操作,其算法的时间复杂度为O(n)。

A)遍历链表和求链表的第i个结点B)在地址为p的结点之后插入一个结点C)删除开始结点D)删除地址为p的结点的后继结点7.链表是一种采用(B )存储结构存储的线性表。

(A )顺序(B )链式( C )星式(D )网状8.线性表若采用链式存储结构时,要求内存中可用存储单元的地址:(D )(A )必须是连续的( B )部分地址必须是连续的(C )一定是不连续的( D )连续或不连续都可以9.线性表L在(B )情况下适用于使用链式结构实现。

(A)需经常修改L中的结点值(B)需不断对L进行删除插入(C)L中含有大量的结点(D)L中结点结构复杂10.在长度为n 的顺序表的第i (1≤i≤n+1) 个位置上插入一个元素,元素的移动次数为( A )A.n-i+1B.n-iC.iD.i-111.线性表是(A)。

数据结构第2章线性表A

数据结构第2章线性表A
15
在线性表的第i个位臵前插入一个元素的示意图如下:
1 2 3 4 插入25 5 12 1
12
13 21
13
21 24 28 30 42 77
2
3 4 5 6 7 8
24
25
6
7 8
28
30 42 77
9
16
3)删除
删除线性表的第i个位臵上的元素
实现步骤: 将第i+1 至第n 位的元素向前移动一个位臵; 表长减1。 注意:事先需要判断,删除位臵i 是否合法? 应当符合条件:1≤i≤n 或 i=[1, n] 核心语句: for ( j=i+1; j<=n; j++ )
18
2.2.3 顺序表的运算效率分析
时间效率分析:
算法时间主要耗费在移动元素的操作上,因此 计算时间复杂度的基本操作(最深层语句频度) T(n)= O (移动元素次数) 而移动元素的个数取决于插入或删除元素的位臵.

讨论1:若在长度为 n 的线性表的第 i 位前 插入一个元素, 则向后移动元素的次数f(n)为: f(n) = n – i + 1
例2 分析学生情况登记表是什么结构。
学号 姓名 性别 年龄 班级
0406010402
0406010405 0406010406 0406010410 0406010413 :
陈杰
邓博 管杰 黄腾达 李荣智 : : :
2004级计软04-1班
2004级计软04-1班 2004级计软04-1班 2004级计软04-1班 2004级计软04-1班 :
InitList( &L ); DestoryList( &L ); //建空表,初始化 //撤销表,释放内存

数据结构第二章习题

数据结构第二章习题

数据结构第二章习题第2章线性表一、单选题1.线性表是具有n个_________的有限序列。

a、表元素B.字符C.数据元素D.数据项2。

线性表格是。

a.一个有限序列,可以为空b.一个有限序列,不可以为空c.一个无限序列,可以为空d.一个无限序列,不可以为空3.线性表采用链表存储时,其地址_________。

a、 U4。

列表中不连续的部分必须是U4。

a.可随机访问任一结点b.插入删除不需要移动元素c.不必事先估计存储空间d.所需空间与其长度成正比5.设线性表有n个元素,以下操作中,_________在顺序表上实现比在链表上实现效率更高。

a、输出I(1≤ 我≤ n) th元素值b.交换第1个元素与第2个元素的值c.顺序输出这n个元素的值d、输出与线性表中给定值x相等的元素序列号6.设线性表中有2n个元素,以下操作中,_________在单链表上实现要比在顺序表上实现效率更高。

a.删除指定的元素b、在最后一个元素后插入新元素。

C.按顺序输出前k个元素d.交换第i个元素和第2n-i-1个元素的值(i=0,1…,n-1)7.如果最常见的操作是获取第i个节点及其前体,请使用___________________。

a.单链表b.双链表c、与单链表相比,双链表的优点之一是。

a.插入和删除操作更简单b.可以进行随机访问c.可以省略表头指针或表尾指针d.访问前后相邻结点更灵活9.带头结点的单链表l为空的判定条件是_________。

a、 l==nullb.l->next==nullc.l->next==ld.l!=无效的10.在一个具有n个结点的有序单链表中插入一个新结点并仍然保持有序的时间复杂度是_________。

a、 o(1)b.o(n)c.o(n2)d.o(nlog2n)11.在一个长度为n(n>1)的带头结点的单链表h上,另设有尾指针r(指向尾结点),执行_________操作与链表的长度有关。

第2章_线性表习题参考答案

第2章_线性表习题参考答案

习题二参考答案一、选择题1. 链式存储结构的最大优点是( D )。

A.便于随机存取B.存储密度高C.无需预分配空间D.便于进行插入和删除操作2. 假设在顺序表{a 0,a 1,……,a n -1}中,每一个数据元素所占的存储单元的数目为4,且第0个数据元素的存储地址为100,则第7个数据元素的存储地址是( D )。

A. 106B. 107C.124D.1283. 在线性表中若经常要存取第i 个数据元素及其前趋,则宜采用( A )存储方式。

A.顺序表B. 带头结点的单链表C.不带头结点的单链表D. 循环单链表4. 在链表中若经常要删除表中最后一个结点或在最后一个结点之后插入一个新结点,则宜采用( C )存储方式。

A. 顺序表B. 用头指针标识的循环单链表C. 用尾指针标识的循环单链表D. 双向链表5. 在一个单链表中的p 和q 两个结点之间插入一个新结点,假设新结点为S,则修改链的java 语句序列是( D )。

A. s.setNext(p); q.setNext(s);B. p.setNext(s.getNext()); s.setNext(p);C. q.setNext(s.getNext()); s.setNext(p);D. p.setNext(s); s.setNext(q);6. 在一个含有n 个结点的有序单链表中插入一个新结点,使单链表仍然保持有序的算法的时间复杂度是( C )。

A. O(1)B. O(log 2n)C. O(n)D. O(n2)7. 要将一个顺序表{a 0,a 1,……,a n-1}中第i 个数据元素a i (0≤i ≤n-1)删除,需要移动( B )个数据元素。

A. iB. n-i-1C. n-iD. n-i+18. 在带头结点的双向循环链表中的p 结点之后插入一个新结点s ,其修改链的java 语句序列是( D )。

A. p.setNext(s); s.setPrior(p); p.getNext().setPrior(s);s.setNext(p.getPrior());B. p.setNext(s); p.getNext().setPrior(s); s.setPrior(p);s.setNext(p.getNext());C. s.setPrior(p); s.setNext(p.getNext()); p.setNext(s);p.getNext().setPrior(s);D. s.setNext(p.getNext()); s.setPrior(p); p.getNext().setPrior(s);p.setNext(s);9. 顺序表的存储密度是( B ),而单链表的存储密度是( A )。

第二章 线性表 答案

第二章 线性表 答案

数据结构与算法上机作业第二章线性表一、选择题1、若长度为n的线性表采用顺序存储结构,在其第i个位置插入一个新的元素算法的时间复杂度为 C 。

A. O(log2n)B. O(1)C. O(n)D. O(n2)2、以下关于线性表的说法中,不正确的是 C 。

A. 线性表中的数据元素可以是数字、字符、结构等不同类型B. 线性表中包含的数据元素个数不是任意的C. 线性表中的每一个结点都有且只有一个直接前驱和直接后继D. 存在这样的线性表:表中各结点都没有直接前驱和直接后继3、在有n个结点的顺序表上做插入、删除结点运算的时间复杂度为 B 。

A. O(1)B. O(n)C. O(n2)D. O(log2n)4、等概率情况下,在有n个结点的顺序表上做插入结点操作,需平均移动的结点数目为C 。

提示:插入的位置有n+1个,移动总数为:1+2+3+……+nA. nB. (n-1)/2C. n/2D. (n+1)/25、在一个长度为n的顺序存储的线性表中查找值为x的元素时,平均查找长度(及x同元素的平均比较次数,假定查找每个元素的概率都相等)为 C 。

A. nB. n/2C. (n+1)/2D. (n-1)/26、在顺序表中,只要知道 D ,就可以求出任一结点的存储地址。

A. 基地址B. 结点大小C. 向量大小D. 基地址和结点大小7、将两个各有n个元素的有序表归并为一个有序表,其最少的比较次数是 A 。

A. nB. 2n-1C. 2nD. n-18、线性表采用链表存储时其存储地址要求 D 。

A. 必须是连续的B. 部分地址必须是连续的C. 必须是不连续的D. 连续的和不连续的都可以9、下面关于线性表的描述中,错误的是 B 。

A. 线性表采用顺序存储,必须占用一片连续的存储单元B. 线性表采用顺序存储,便于进行插入和删除操作C. 线性表采用链式存储,不必占用一片连续的存储单元D. 线性表采用链式存储,便于插入和删除操作10、向具有n个结点的有序单链表中插入一个新结点并仍然有序的时间复杂度是 BA. O(1)B. O(n)C. O(n2)D. O(log2n)11、在一个带头结点的单链表HL中,若要向表头插入一个由指针p指向的结点,则执行的语句是 D 。

数据结构(C语言版)第2版习题答案—严蔚敏

数据结构(C语言版)第2版习题答案—严蔚敏
数据结构( C语言版)(第 2版) 课后习题答案
李冬梅 2015.3
目录
第 1 章 绪论 ..................................................................................................................
i 个结点和求第 i 个结点的直接前驱都可
以直接通过数组的下标直接定位,时间复杂度是
O(1) 。
( 3) 向一个有 127 个元素的顺序表中插入一个新元素并保持原来顺序不变,平均要移
动 的元素个数为(
)。
A. 8
B . 63.5
C . 63
D. 7
答案: B
解释:平均要移动的元素个数为:
n/2 。
( 4)链接存储的存储结构所占存储空间(
)。
A.存储结构
B
.存储实现
C.逻辑结构
D
.运算实现
答案: C
( 3)通常要求同一逻辑结构中的所有数据元素具有相同的特性,这意味着(
)。
A .数据具有同一特点
B.不仅数据元素所包含的数据项的个数要相同,而且对应数据项的类型要一致
C.每个数据元素都一样
D.数据元素所包含的数据项的个数要相等
答案: B
( 4)以下说法正确的是(
A . 110 答案: B
B . 108
解释:顺序表中的数据连续存储,所以第
C . 100
D . 120
5 个元素的地址为: 100+2*4=108 。
( 2)在 n 个结点的顺序表中,算法的时间复杂度是
O(1) 的操作是(
)。
A .访问第 i 个结点( 1≤ i ≤ n)和求第 i 个结点的直接前驱( 2≤ i≤ n)
相关主题
  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
L s x a
核心语句: s->next=L->next;L->next=s;
17
分析算法 2.11
编写程序,建立一个存储英文字母的链表, 编写程序,建立一个存储英文字母的链表, 最后输出链表中全部结点的内容。 最后输出链表中全部结点的内容。
#include "stdio.h" #define L sizeof(struct letter) struct letter { char x; struct letter *next; };
13
2.插入元素操作
在链表中插入一个元素的示意图如下: 在链表中插入一个元素的示意图如下:
p a b p a s x b
p->next
s->next
插入步骤: 插入步骤: Step1:s->next=p->next; Step1: Step2:p->next=s ; Step2:
元素x结点应预先生成: 元素x结点应预先生成: S=(Linklist)malloc(sizeof(lnode)); S->data=x; S->next=NULL;
a1
a2
……
an
循环链表示意图
Байду номын сангаас
3
2、头指针、头结点和首元结点 、头指针、 示意图如下: 示意图如下: head info a1 a2 … an
^
头指针
头结点
首元结点
头指针是指向链表中第一个结点(或为头结点或为首元结点) 头指针是指向链表中第一个结点(或为头结点或为首元结点) 是指向链表中第一个结点 的指针;单链表可由一个头指针唯一确定。 的指针;单链表可由一个头指针唯一确定。 头结点是在链表的首元结点之前附设的一个结点; 头结点是在链表的首元结点之前附设的一个结点;数据域内 是在链表的首元结点之前附设的一个结点 只放空表标志和表长等信息; 只放空表标志和表长等信息; 首元结点是指链表中存储线性表第一个数据元素a 的结点。 首元结点是指链表中存储线性表第一个数据元素a1的结点。 是指链表中存储线性表第一个数据元素
存储地址 1 7 13 19 25 31 37 43 数据域 LI QIAN SUN WANG WU ZHAO ZHENG ZHOU 指针域 43 13 1 NULL 37 7 19 25
5
答:头指针是指向 头指针是指向 链表中第一个结点 的指针, 的指针,因此关键 是要寻找第一个结 是要寻找第一个结 地址。 点的地址。 H 31 ZHAO 7
7
附:结构数据类型及其C语言表示法 结构数据类型及其 语言表示法 data *next
(1)类型定义为: )类型定义为: struct lnode { //lnode是自定义结构类型名称 是自定义结构类型名称 //定义数据域的变量名及其类型 char data; struct lnode *next; //定义指针域的变量名及其类型 }
Lb
Lc
Pc 2
Pc 3
Pc 5 …
Pc 11 ^
法二: 法二: 分析算法2.12(书上P31)
23
算法实现: 算法实现: Void MergeList_L(LinkList &La,LinkList &Lb,LinkList &Lc) { //按值排序的单链表 按值排序的单链表LA,LB,归并为LC后也按值排序 ,归并为 后也按值排序 按值排序的单链表 pa=La-->next; pb=Lb-->next; Lc=pc=La; //初始化 ; 初始化 while(pa&&pb) //将pa 、pb结点按大小依次插入 中 结点按大小依次插入C中 将 结点按大小依次插入 { if(pa->data<=pb->data) { pc->next=pa; pc=pa; pa=pa->next;} else { pc->next=pb; pc=pb; pb=pb->next;} } pc->next = pa?pa:pb ; free(Lb); } //MergeList_L //插入剩余段 插入剩余段 //释放 的头结点 释放Lb的头结点 释放
10
二、单链表的结构描述
typedef struct Lnode { ElemType data; //数据域 struct Lnode *next; //指针域 }Lnode, *LinkList; // *LinkList为Lnode类型的指针
11
2.3.2 链表的实现 1.读取元素操作 GetElem (L,i, &e) 2.插入元素操作 ListInsert (&L, i, e) 3.删除元素操作 ListDelete (&L, i, &e) 4.单链表的建立和输出 5.链表的归并
21
用链表可表示为: 用链表可表示为:
头结点 La
3
Lb
5 6
8 8
11 9
/\
2
11
/\
Lc
2 8
8
3
9
5
11
6
11
/\
22
Pa、 用于搜索 用于搜索La和 , 指向新链表当前结点 法一: 法一: 、Pb用于搜索 和Lb, Pc指向新链表当前结点 La Pa 3 Pb 2 Pa 5 Pb 6 8 9 Pa 8 Pa 11 ^ Pb 11 ^
15
4 单链表的建立和输出
• 编写程序,建立一个存储英文字母的链 编写程序, 最后输出链表中全部结点的内容。 表,最后输出链表中全部结点的内容。
16
单链表的建立有两种方法: 单链表的建立有两种方法: • 法一:顺序建立单链表 法一:
p
L a s
p
x
核心语句:p->next=s;p=s; 法二: 法二:逆序建立单链表
12
1 读取元素操作
单链表中想取得第i个元素, 单链表中想取得第 个元素,必须从头指针出发 个元素 寻找, 寻找,不能随机存取 。 Status GetElem_L(LinkList L, int i, ElemType &e) { P=L->next; j=1; //p指向第一个结点,j为计数器 指向第一个结点, 指向第一个结点 为计数器 while(p&&j<i) { p=p->next; ++j;} if(!p||j>i) return ERROR; e=p->data; return OK; }
2.3 线性表的链式表示和实现
2.3.1 链表的表示 2.3.2 链表的实现 2.3.3 其他链表形式
1
画出26 个英文字母表的链式存储结构。 例1 画出 个英文字母表的链式存储结构。
解:该字母表的逻辑结构为:( a, b, … ,y, z) 该字母表的逻辑结构为: )
该字母表在内存的链式存放示意图如下: 该字母表在内存的链式存放示意图如下: head a b …… z
4
例: 一个线性表的逻辑结构为: 一个线性表的逻辑结构为:
ZHAO,QIAN,SUN,LI,ZHOU,WU,ZHENG,WANG), ),其存 (ZHAO,QIAN,SUN,LI,ZHOU,WU,ZHENG,WANG),其存 储结构用单链表表示如下,请问其头指针 头指针的 是多少? 储结构用单链表表示如下,请问其头指针的值是多少?
8
(2) 每个结点的分量如何表示? ) 每个结点的分量如何表示?
p
data
*next
方式:先让指针变量 指向该结点的首地址 然后用: 指向该结点的首地址, 方式:先让指针变量p指向该结点的首地址,然后用: p->data='a'; p->next=q;
9
练习
个元素的指针, 设p为指向链表的第i个元素的指针,则第i个元素的 数据域写为 p->data ,指针域写为 p->next 。 ai的值 ai+1的地址
18
struct letter *create() { struct letter *head,*p; int i; i=1; head=NULL; for(i=26;i>=1;i---) for(i=26;i>=1;i--) { p=(struct letter *)malloc(L); p->x=i+64; p->next=head; head=p; } return(head); }
14
思考:步骤1 能互换么? 思考:步骤1和2能互换么? 分析算法2.9 分析算法2.9
3.删除元素操作
在链表中删除某元素的示意图如下: 在链表中删除某元素的示意图如下:
p a
× b
×
c
p->next
(p->next) -> next
删除步骤(即核心语句): 删除步骤(即核心语句): q = p->next; //保存b的指针,靠它才能指向c p->next=q->next; //a、c两结点相连 、 两结点相连 free(q) ; //删除 结点,彻底释放 删除b结点 删除 结点, 思考: 省略free(q)语句行不行? 语句行不行 思考: 省略 语句行不行? 分析算法2 分析算法2.10
/\
各结点由两个域组成: 各结点由两个域组成: 数据域:存储数据元素信息; 数据域:存储数据元素信息; 指针域:存储直接后继的存储位置。 指针域:存储直接后继的存储位置。
2
一、与链式存储有关的术语
1、单链表、双链表、多链表、循环链表: 、单链表、双链表、多链表、循环链表 • 结点只包含一个指针域的链表,称为单链表或线性链表; 结点只包含一个指针域的链表,称为单链表 线性链表; 单链表或 • 有两个指针域的链表,称为双链表; 有两个指针域的链表,称为双链表 双链表; • 有多个指针域的链表,称为多链表; 有多个指针域的链表,称为多链表 多链表; • 首尾相接的链表称为循环链表。 首尾相接的链表称为循环链表 循环链表。
相关文档
最新文档