链表习题高考真题
C程序设计(链表)习题与答案
一、单选题1、链表不具有的特点是（）。
A.不必事先估计存储空间B.插入、删除不需要移动元素C.可随机访问任一元素D.所需空间与线性表长度成正比正确答案：C2、链接存储的存储结构所占存储空间（）。
A.分两部分，一部分存放结点值，另一部分存放结点所占单元数B.只有一部分，存放结点值C.分两部分，一部分存放结点值，另一部分存放表示结点间关系的指针D.只有一部分，存储表示结点间关系的指针正确答案：C3、链表是一种采用（）存储结构存储的线性表。
A.网状B.星式C.链式D.顺序正确答案：C4、有以下结构体说明和变量的定义，且指针p指向变量a，指针q指向变量b，则不能把结点b连接到结点a之后的语句是（）。
struct node {char data;struct node *next;} a,b,*p=&a,*q=&b;A.(*p).next=q;B.p.next=&b;C.a.next=q;D.p->next=&b;正确答案：B5、下面程序执行后的输出结果是（）。
#include <stdio.h>#include <stdlib.h>struct NODE {int num; struct NODE *next;};int main(){ struct NODE *p,*q,*r;p=(struct NODE*)malloc(sizeof(struct NODE));q=(struct NODE*)malloc(sizeof(struct NODE));r=(struct NODE*)malloc(sizeof(struct NODE));p->num=10; q->num=20; r->num=30;p->next=q;q->next=r;printf("%d",p->num+q->next->num);return 0;}A.30B.40C.10D.20正确答案：B6、下面程序执行后的输出结果是（）。
第08章指针和链表真题
历年真题（指针）一、2003年1月10.以下定义语句中，错误的是（A ） int a{}={1,2}; （B ） char *a[3];（C ） char s[10]=”text ”; （D ） int n=5,a[n];14.下列语句执行后的结果是 。
y=5;p=&y;x=*p++;（A ）x=5，y=5 （B ）x=5，y=6（C ）x=6，y=5 （D ）x=6，y=615. 执行下面的语句后，表达式*(p[0]+1)+**(q+2)的值为 。
int a[]={5,4,3,2,1};*p[]={a+3,a+2,a+1,a};**q=p;（A ）8 （B ）7 （C ）6 （D ）516. 经过下面的语句int I,a[10],*p;定义后，下列语句中合法的是 。
（A ）p=100; （B ）p=a[5];（C ）p=a+2; （D ）p=&(i+2);29. 有如下程序main(){ char ch[2][5]={“6937”, “8254”},*p[2];int i,j,s=0;for(i=0;i<2;i++) p[i]=ch[i];for(i=0;i<2;i++)for(j=0;p[i][j]>‟0‟;j+=2)s=10*s+p[i][j]-…0‟;printf(“%d\n ”,s);}该程序的输出结果是 。
（A ）69825 （B ）63825 （C ）6385 （D ）69382530. 若建立如下图所示的单项链表结构date nextheadS在该链表结构中，指针p ，s 分别指向图中所示节点，则不能将s 所指的节点插入链表末尾仍构成单向链表的语句组是 。
（A ） p=p->next;s->next=p;p->next=s;（B）p=p->next;s->next=p->next;p->next=s;（C）s->next=NULL;p =p->next;p->next=s;（D）p=(*p).next;(*s).next=(*p).next; (*p).next=s;试卷二试题二：把下列程序补充完整实现两个字符串的比较，即自己写个strcmp函数，函数原型为：int strcmp(char *p1,char *p2)设p1指向字符串s1，p2指向字符串s2，要求：当s1=s2时，返回值为0。
第2章习题(带答案)
第2章习题（带答案）1．链表不具有的特点是A．可随机访问任一个元素B.插入删除不需要移动元素C.不必事先估计存储空间D.所需空间与线性表长度成正比2．在一个具有n个结点的单链表中查找值为某的某结点，若查找成功，则平均比较个结点。
A．nB.n/2C.(n-1)/2D.(n+1)/23.在单链表中P所指结点之后插入一个元素某的主要操作语句序列是=(node某)malloc(izeof(node));、->data=某;、->ne某t=p->ne某t、p->ne某t=。
4.在单链表中查找第i个元素所花的时间与i成正比。
（√）5．在带头结点的双循环链表中，任一结点的前驱指针均不为空。
（√）6.用链表表示线性表的优点是()。
A.便于随机存取C.便于插入与删除B.花费的存储空间比顺序表少D.数据元素的物理顺序与逻辑顺序相同7.在双向链表中删除P所指结点的主要操作语句序列是p->prior->ne某t=p->ne某t;、p->ne某t->prior=p->prior;、free(p);8.下述哪一条是顺序存储结构的优点？（）A．存储密度大B．插入运算方便C．删除运算方便D．可方便地用于各种逻辑结构的存储表示9．若某表最常用的操作是在最后一个结点之后插入一个结点或删除最后一个结点。
则采用（）存储方式最节省运算时间。
A．单链表B．双链表C．单循环链表D．带头结点的双循环链表10.对任何数据结构链式存储结构一定优于顺序存储结构。
（某）11.对于双向链表,在两个结点之间插入一个新结点需修改的指针共4个，单链表为____2___个。
12.以下数据结构中，（）是非线性数据结构A．树B．字符串C．队列D．栈13.若某线性表最常用的操作是存取任一指定序号的元素和在最后进行插入和删除运算，则利用（）存储方式最节省时间。
A．顺序表B．双链表C．带头结点的双循环链表D．单循环链表14.“线性表的逻辑顺序和物理顺序总是一致的。
链表练习题及答案
1、已知L是带表头的单链表，其P结点既不是首元结点，也不是尾元结点，a.删除p结点的直接后继的语句是11，3，14b.删除p结点的直接前驱的语句是10，12，8，11，3，14c.删除p结点的语句序列是10，7，3，14d.删除首元结点的语句序列是12，10，13，14e.删除尾元结点的语句序列是9，11，3，14（1）p=p->next;(2) p->next=p;(3)p->next=p->next->next;(4)p=p->next->next;(5)while(p)p=p->next;(6)whlie(Q->next){p=Q;Q=Q->next;}(7)while(p->next!=Q)p=p->next;(8)while(p->next->next!=Q)p=p->next;(9)while(p->next->next)p=p->next;(10)Q=p;(11)Q=p->next;(12)p=L;(13)L=L->next;(14)free(Q);2、已知L是带表头的单链表，其P结点既不是首元结点，也不是尾元结点，a.在p结点后插入s结点的语句序列是4，1b.在p结点前插入s结点的语句序列是7，11，8，4，1c.在表首插入s结点的语句序列是5，12d.在表尾插入s结点的语句序列是7，9，4，1或11，9，1，61.p-> next =s;2.p-> next=p-> next-> next;3.p->next=s->next;4.s->next=p-> next;5.s-> next=L;6.s->next=NULL;7.q=p ;8.while(p->next!=q) p=p->next;9.while(p->next!=NULL) p=p->next;10.p =q;11.p=L;12.L=s;13.L=P;3、已知P结点是某双向链表的中间结点，从下列提供的答案中选择合适的语句序列a.在P结点后插入S结点的语句序列是12，7，3，6b.在P结点前插入S结点的语句序列是13，8，5，4c.删除p结点的直接后继结点的语句序列是15，1，11，18d.删除p结点的直接前驱结点的语句序列是16，2，10，18e.删除p结点的语句序列是9，14，171.P->next=P->next->next;2.P->priou=P->priou->priou;3.P->next=S;4.P->priou=S;5.S->next=P;6.S->priou=P;7.S->next=P->next;8.S->priou=P->priou;9.P->priou->next=P->next;10.P->priou->next=P;11.P->next->priou=P;12.P->next->priou=S;13.P->priou->next=S;14.P->next->priou=P->priou;15.Q=p->next;16.Q=P->priou;17.free(P);18.free(Q);。
历年链表考题与答案
历年链表考题及答案[2005秋II.14]设已建立了两条单向链表，这两链表中的数据已按从小到大的次序排好，指针h1和h2分别指向这两条链表的首结点。
链表上结点的数据结构如下：structnode{intdata;node*next;};以下函数node*Merge(node*h1,node*h2)的功能是将h1和h2指向的两条链表上的结点合并为一条链表，使得合并后的新链表上的数据仍然按升序排列，并返回新链表的首结点指针。
算法提示：首先，使newHead和q都指向首结点数据较小链表的首结点，p指向另一链表首结点。
其次，合并p和q所指向的两条链表。
在q不是指向链尾结点的情况下，如果q 的下一个结点数据小于p指向的结点数据，则q指向下一个结点；否则使p1指向q的下一个结点，将p指向的链表接到q所指向的结点之后，使q指向p所指向的结点，使p指向p1所指向的链表。
直到p和q所指向的两条链表合并结束为止。
注意，在合并链表的过程中，始终只有两条链表。
[函数]（4分）node*Merge(node*h1,node*h2){node*newHead,*p,*p1;//使newHead和q指向首结点数据较小链表的首结点，p指向另一链表首结点if((27)){newHead=h1;p=h2;}//h1->data<h2->dataelse{newHead=h2;p=h1;}node*q=newHead;//合并两条链表while(q->next){if(q->next->data<p->data)(28);//q=q->nextelse{(29);//p1=q->nextq->next=p;q=p;p=p1;}}q->next=p;(30);//returnnewNead}[2005春II.11]设已建立一条单向链表，指针head指向该链表的首结点。
结构体与链表习题附答案
结构体与链表习题附答案一、选择题1、在说明一个结构体变量时系统分配给它的存储空间是（）．A）该结构体中第一个成员所需的存储空间B）该结构体中最后一个成员所需的存储空间C）该结构体中占用最大存储空间的成员所需的存储空间D）该结构体中所有成员所需存储空间的总和。
2．设有以下说明语句，则以下叙述不正确的是()tructtu{inta;floatb;}tutype;A.truct是结构体类型的关键字B.tructtu是用户定义的结构体类型C.tutype是用户定义的结构体类型名D.a和b都是结构体成员名3、以下对结构体变量tu1中成员age的合法引用是（）#includetructtudent{intage;intnum;}tu1,某p;p=&tu1;A)tu1->ageB)tudent.ageC)p->ageD)p.age4、有如下定义：Structdate{intyear,month,day;};Structworklit{Charname[20];Chare某;Structdatebirthday;}peron;对结构体变量peron的出生年份进行赋值时，下面正确的赋值语句是()Aworklit.birthday.year=1978Bbirthday.year=1978Cperon.birthday .year=1958Dperon.year=19585、以下程序运行的结果是()#include”tdio.h”main(){tructdate{intyear,month,day;}today;printf(“%d\\n”,izeof(truct date));}A.6B.8C.10D.126、对于时间结构体tructdate{intyear,month,day;charweek[5];}则执行printf(“%d\\n”,izeof(tructdate))的输出结果为(A.12B.17C.18D.207、设有以下语句：tructt{intn;charname[10]};tructta[3]={5,“li”,7,“wang”,9,”zhao”},某p;p=a;则以下表达式的值为6的是()A.p++->nB.p->n++C.(某p).n++D.++p->n8、设有以下语句，则输出结果是()tructLit{intdata;tructLit某ne某t;};tructLita[3]={1,&a[1],2,&a[2],3,&a[0]},某p;p=&a[1];printf(\printf(\printf(\}A.131B.311C.132D.2139、若有以下语句，则下面表达式的值为1002的是()tructtudent{intage;intnum;};tructtudenttu[3]={{1001,20},{1002,19},{1003,21}};)tructtudent某p;p=tu;A.(p++)->numB.(p++)->ageC.(某p).numD.(某++p).age10、下若有以下语句，则下面表达式的值为()tructcmpl某{int某;inty;}cnumn[2]={1,3,2,7};cnum[0].y/cnum[0].某某cnum[1].某;A.0B.1C.3D.611、若对员工数组进行排序，下面函数声明最合理的为（）。
习题3(链表)
习题3（链表）一、选择题（1）链接存储的存储结构所占存储空间（ A ）。
A）分两部分，一部分存放结点值，另一部分存放表示结点间关系的指针B）只有一部分，存放结点值C）只有一部分，存储表示结点间关系的指针D）分两部分，一部分存放结点值，另一部分存放结点所占单元数（2）线性表若采用链式存储结构时，要求内存中可用存储单元的地址（ D ）。
A）必须是连续的B）部分地址必须是连续的C）一定是不连续的D）连续或不连续都可以（3）线性表Ｌ在（ B ）情况下适用于使用链式结构实现。
A）需经常修改结点值B）需不断删除插入C）含有大量的结点D）结点结构复杂（4）单链表的存储密度（ C ）。
A）大于1 B）等于1 C）小于1 D）不能确定（5）若指定有n个元素的向量，则建立一个有序单链表的时间复杂性的量级是（ C ）。
A）O(1) B）O(n) C）O(n2) D）O(nlog2n)（6）在单链表中，要将s所指结点插入到p所指结点之后，其语句应为（ D ）。
A）s->next=p+1; p->next=s; B）(*p).next=s; (*s).next=(*p).next;C）s->next=p->next; p->next=s->next; D）s->next=p->next; p->next=s;（7）在双向链表存储结构中，删除p所指的结点时须修改指针（ A ）。
A）p->next->prior=p->prior; p->prior->next=p->next;B）p->next=p->next->next; p->next->prior=p;C）p->prior->next=p; p->prior=p->prior->prior;D）p->prior=p->next->next; p->next=p->prior->prior;（8）在双向循环链表中，在p指针所指的结点后插入q所指向的新结点，其修改指针的操作是（ C ）。
数据结构真题及其答案解析
数据结构真题及其答案解析引言在计算机科学领域中，数据结构是一个关键概念。
它是指组织和存储数据的方法和原则。
良好的数据结构可以大大提高算法的效率和性能。
在学习和应用数据结构的过程中，了解和解析真题对于提高对数据结构的理解和应用能力至关重要。
本文将讨论几个典型的数据结构真题，并提供详细的答案解析。
链表题目1. 题目描述：实现一个单向链表，具有以下功能：a) 在链表末尾添加一个元素。
b) 删除链表中指定位置的元素。
c) 返回链表的长度。
解析：这道题要求你实现一个链表数据结构，并完成对应的功能。
为了实现一个单向链表，我们需要定义一个节点类，每个节点包含一个值和指向下一个节点的指针。
在链表的尾部添加一个元素时，我们需要遍历链表直至最后一个节点，然后将新的节点链接到最后一个节点的指针上。
删除链表中指定位置的元素时，我们需要找到该位置的前一个节点，并将其指针指向目标位置的下一个节点。
返回链表的长度则只需要遍历链表并记录节点数即可。
栈题目2. 题目描述：实现一个栈数据结构，具有以下功能：a) 入栈（Push）操作，将一个元素加入栈中。
b) 出栈（Pop）操作，从栈中取出一个元素并将其删除。
c) 返回栈中元素的个数。
解析：栈是一种后进先出（Last In First Out，LIFO）的数据结构，类似于现实生活中的栈。
我们可以使用数组或链表来实现一个栈。
入栈操作将一个元素添加到栈的顶部，而出栈操作则取出栈顶的元素并将其删除。
为了实现这个功能，我们需要维护一个指向栈顶的指针，并更新指针的位置。
返回栈中元素的个数只需要记录当前栈的大小即可。
二叉树题目3. 题目描述：实现一个二叉树数据结构，具有以下功能：a) 添加一个节点到二叉树中。
b) 删除二叉树中指定的节点。
c) 查找指定值在二叉树中的位置。
解析：二叉树是一种由节点组成的层级结构，其中每个节点最多有两个子节点。
为了实现一个二叉树，我们需要定义一个节点类，每个节点包含一个值和指向左右子节点的指针。
链表习题——精选推荐
一选择题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. 静态链表中指针表示的是（c ）. A．内存地址B．数组下标C．下一元素地址D．左、右孩子地址8. 链表不具有的特点是（b ）A．插入、删除不需要移动元素B．可随机访问任一元素C．不必事先估计存储空间D．所需空间与线性长度成正比9. 下面的叙述不正确的是（b,c ）A．线性表在链式存储时，查找第i个元素的时间同i的值成正比B. 线性表在链式存储时，查找第i个元素的时间同i的值无关C. 线性表在顺序存储时，查找第i个元素的时间同i 的值成正比D. 线性表在顺序存储时，查找第i个元素的时间同i的值无关10．非空的循环单链表head的尾结点p↑满足（a ）。
A．p↑.link=head B．p↑.link=NIL C．p=NIL D．p= head 11．循环链表H的尾结点P的特点是（a ）。
链表练习题及答案
链表练习题及答案1、已知L是带表头的单链表，其P结点既不是首元结点，也不是尾元结点，a.删除p结点的直接后继的语句是11，3，14b.删除p结点的直接前驱的语句是10，12，8，11，3，14c.删除p结点的语句序列是10，7，3，14d.删除首元结点的语句序列是12，10，13，14e.删除尾元结点的语句序列是9，11，3，14（1）p=p->next;(2) p->next=p;(3)p->next=p->next->next;(4)p=p->next->next;(5)while(p)p=p->next;(6)whlie(Q->next){p=Q;Q=Q->next;}(7)while(p->next!=Q)p=p->next;(8)while(p->next->next!=Q)p=p->next;(9)while(p->next->next)p=p->next;(10)Q=p;(11)Q=p->next;(12)p=L;(13)L=L->next;(14)free(Q);2、已知L是带表头的单链表，其P结点既不是首元结点，也不是尾元结点，a.在p结点后插入s结点的语句序列是4，1b.在p结点前插入s结点的语句序列是7，11，8，4，1c.在表首插入s结点的语句序列是5，12d.在表尾插入s结点的语句序列是7，9，4，1或11，9，1，61.p-> next =s;2.p-> next=p-> next-> next;3.p->next=s->next;4.s->next=p-> next;5.s-> next=L;6.s->next=NULL;7.q=p ;8.while(p->next!=q) p=p->next;9.while(p->next!=NULL) p=p->next;10.p =q;11.p=L;12.L=s;13.L=P;3、已知P结点是某双向链表的中间结点，从下列提供的答案中选择合适的语句序列a.在P结点后插入S结点的语句序列是12，7，3，6b.在P结点前插入S结点的语句序列是13，8，5，4c.删除p结点的直接后继结点的语句序列是15，1，11，18d.删除p结点的直接前驱结点的语句序列是16，2，10，18e.删除p结点的语句序列是9，14，171.P->next=P->next->next;2.P->priou=P->priou->priou;3.P->next=S;4.P->priou=S;5.S->next=P;6.S->priou=P;7.S->next=P->next;8.S->priou=P->priou;9.P->priou->next=P->next;10.P->priou->next=P;11.P->next->priou=P;12.P->next->priou=S;13.P->priou->next=S;14.P->next->priou=P->priou;15.Q=p->next;16.Q=P->priou;17.free(P);18.free(Q);。
单链表题目和答案
第2章自测卷答案一、 填空1•顺序表中逻辑上相邻的元素的物理位置相互相邻。
单链表中逻辑上相邻的元素的物理位置丕相邻。
2. 在单链表中，除了首元结点外，任一结点的存储位宜由其直接前驱结点值域指示。
3. 在n 个结点的单链表中要删除已知结点*p,需找到它的地址。
二、 判断正误（在正确的说法后面打勾，反之打叉）1. 链表的每个结点中都恰好包含一个指针。
X2. 链表的物理存储结构具有同链表一样的顺序。
X3. 链表的删除算法很简单，因为当删除链中某个结点后，il •算机会自动地将后续的各个单元向前移动。
X4. 线性表的每个结点只能是一个简单类型，而链表的每个结点可以是一个复杂类型。
Y5. 顺序表结构适宜于进行顺序存取，而链表适宜于进行随机存取。
Y6. 顺序存储方式的优点是存储密度大，且插入、删除运算效率高。
X7. 线性表在物理存储空间中也一定是连续的。
X&线性表在顺序存储时，逻辑上相邻的元素未必在存储的物理位置次序上相邻。
X9. 顺序存储方式只能用于存储线性结构。
X10. 线性表的逻辑顺序与存储顺序总是一致的。
X三、 单项选择题（A ） 1.链接存储的存储结构所占存储空间：（A ） 分两部分，一部分存放结点值，另一部分存放表示结点间关系的指针（B ） 只有一部分，存放结点值（C ） 只有一部分，存储表示结点间关系的指针（D ） 分两部分，一部分存放结点值，另一部分存放结点所占单元数（B ） 2.链表是一种采用存储结构存储的线性表：（A ）顺序 （B ）链式 （C ）星式 （D ）网状（D ） 3.线性表若采用链式存储结构时，要求内存中可用存储单元的地址：（A ）必须是连续的 （B ）部分地址必须是连续的（C ） 一定是不连续的 （D ）连续或不连续都可以（B ） 4.线性表L 在情况下适用于使用链式结构实现。
（A ）需经常修改L 中的结点值 （C ）L 中含有大量的结点 C ） 5.单链表的存储密度（A ）大于1： （B ）等于1： A ） 6、在单链表的一个结点中有个指针。
计算机题数据结构中的链表与树(试题)
计算机题数据结构中的链表与树（试题）在计算机科学领域的数据结构中，链表和树是两个重要的概念。
它们在解决各种问题时具有不同的特性和应用。
本文将介绍链表和树的定义、特点以及它们在计算机科学中的应用。
通过试题形式的探讨，读者可以更好地理解和应用链表和树这两种数据结构。
1. 链表链表是一种线性数据结构，其中的元素按顺序存储，并通过指针相互连接。
链表由节点组成，每个节点包含一个值和指向下一个节点的指针。
链表具有动态扩展的特性，可以在运行时灵活地添加或删除节点。
链表分为单向链表和双向链表，双向链表在每个节点中还包含指向前一个节点的指针。
试题1：请写出单向链表的定义，并画出以下链表的结构图。
```C++struct ListNode {int val;ListNode *next;ListNode(int x) : val(x), next(NULL) {}};// 链表结构图// head -> 1 -> 2 -> 3 -> NULL```试题2：给定一个单向链表的头节点 `head`，请编写代码将链表反转。
```C++ListNode* reverseList(ListNode* head) {ListNode* prev = NULL;ListNode* current = head;while (current != NULL) {ListNode* next = current->next;current->next = prev;prev = current;current = next;}return prev;}```链表的优点是插入和删除节点的时间复杂度为O(1)，但访问特定位置的元素需要遍历整个链表，时间复杂度为O(n)。
2. 树树是一种非线性的数据结构，由节点和边组成。
树中的一个节点被称为根节点，每个节点可以有零个或多个子节点。
树的节点之间通过边连接，形成层次结构。
顺序表、链表题库
顺序表、链表题库第三章顺序表⼀、填空1．若线性表最常⽤的操作是存取第i 个元素及其前驱元素的值，则采⽤（）存储结构最节省运算时间。
2．顺序存储结构的线性表中所有元素的地址（）连续。
3．顺序存储结构的线性表其物理结构与逻辑结构是（）的。
4．在具有n个元素的顺序存储结构的线性表任意⼀个位置中插⼊⼀个元素，在等概率条件下，平均需要移动（）个元素。
5．在具有n个元素的顺序存储结构的线性表任意⼀个位置中删除⼀个元素，在等概率条件下，平均需要移动（）个元素。
6．在具有n个元素的顺序存储结构的线性表中查找某个元素，平均需要⽐较（）次。
7．当线性表的元素基本稳定，且很少进⾏插⼊和删除操作，但要求以最快的速度存取线性表中第i个元素时，应采⽤( )存储结构。
8．顺序存储结构的线性表中，插⼊或删除某个元素时，元素移动的次数与其位置（）关。
（填有或⽆）。
9．顺序存储结构的线性表中，访问第i个元素与其位置（）关。
（填有或⽆）。
10．在具有n个元素的顺序存储结构的线性表中要访问第i个元素的时间复杂度是（）。
11．在顺序表L中的i个位置插⼊某个元素x，正常插⼊时，i位置以及i位置以后的元素需要后移，⾸先后移的是（）个元素。
12．要删除顺序表L中的i位置的元素x，正常删除时，i位置以后的元素需要前移，⾸先前移的是（）元素。
13．若顺序表中的元素是从1位置开始存放的，要在具有n个元素的顺序表中插⼊⼀个元素，合法的插⼊位置是（）。
14．若顺序表中的元素是从1位置开始存放的，要删除具有n个元素的顺序表中某个元素，合法的删除位置是（）。
15．在具有n个元素的顺序存储结构的线性表中删除某个元素的时间复杂度是（）。
16．在具有n个元素的顺序存储结构的线性表中插⼊某个元素的时间复杂度是（）。
17．在具有n个元素的顺序存储结构的线性表中要访问第i个元素的后继结点的时间复杂度是（）。
18．在具有n个元素的顺序存储结构的线性表中，若给定的是某个元素的关键字值，要访问该元素的其它信息的时间复杂度是（）。
链表概念及其表示经典练习题
链表概念及其表示经典练习题
链表是计算机中常用的一种数据结构，它由若干个节点组成，
每个节点包含数据和指向下一个节点的指针。
链表分为单向链表、
双向链表和循环链表。
单向链表
单向链表中，每个节点只有一个指向下一个节点的指针，最后
一个节点的指针指向空地址。
单向链表的插入和删除操作比较简单，但是查找操作需要从头节点开始遍历。
练题
1. 实现单向链表的创建、插入、删除和遍历操作。
2. 反转单向链表。
3. 查找单向链表中倒数第k个节点。
双向链表
双向链表中，每个节点有两个指针，一个指向前一个节点，一个指向下一个节点。
双向链表的插入和删除操作比单向链表更加灵活，但是需要对前后节点的指针进行操作。
练题
1. 实现双向链表的创建、插入、删除和遍历操作。
2. 反转双向链表。
3. 查找双向链表中倒数第k个节点。
循环链表
循环链表中，最后一个节点的指针指向头节点，形成一个环。
相比于单向链表和双向链表，循环链表更加灵活，可以实现循环遍历。
练题
1. 实现循环链表的创建、插入、删除和遍历操作。
2. 反转循环链表。
3. 查找循环链表中倒数第k个节点。
以上是链表的概念及其表示，以及相应的经典练习题。
掌握这些知识，可以对链表有更深入的理解，也更利于进行编程实现。
2024-2025学年高二上学期浙教版(2019)选修一 2.2 链表 同步练习(含答案)
2023-2024学年高二上学期浙教版(2019)选修一2.2 链表一、选择题1．如下图所示的链表：假如要查找元素11，共需遍历的次数为（）A．5B．6C．7D．82．寻宝游戏中通过一个线索找到下一个线索，最好用下列数据组织形式中的（）来表示。
A．数组B．链表C．栈D．队列3．小张准备去多个城市旅游，他设计的行程若采用链表结构表示，如图a所示。
若行程有变，需在“上海”与“成都”之间增加一站“杭州”，链表修改为如图b所示，有以下可选操作：①“上海”所在节点的next值赋为“杭州”所在节点的next值①“上海”所在节点的next值赋为5①“杭州”所在节点的next值赋为“上海”所在节点的next值①“杭州”所在节点的next值赋为-1链表更新顺序正确的是（）A．①①B．①①C．①①D．①①4．把单向链表第1个节点的位置口叫奇数位置，第2个节点的位置叫偶数位置，以此类推。
现将所有偶数位置的节点依次取出后，放在所有奇数位置节点的后面。
实现该功能的Python 代码段如下，方框中应填入的正确代码为（）a=[['a',1],['b',2]. ['c',3],['d',4],[ 'e',-1]]head=odd=0 #链表a头节点指针是headevenhead=even=a[head][1]while even!=-1 and a[even][1]!=-1:a[odd][1]=evenhead #将链表连接在奇数链表之后A．B．C．D．5．链表中的节点通常包含哪两部分（）A．数据域和控制域B．数据域和指针域C．指令域和地址域D．标志域和内容域6．有如下Python程序，用于判断链表是否为回文链表（回文链表是指正序遍历和逆序遍历得到的结点顺序一致的链表），则划线处代码是（）a=[[1,1],[2,2],[8,3],[2,4],[1,-1]]st=[];head=0;flag=Trueslow, fast=head, headwhile ① :st.append (a[slow][o])slow=a[slow][1]fast=a[a[fast][1]][1]if ① :slow=a[slow][1]while slow!=-1:if st.pop () !=a[slow][0]:flag=Falseslow=a[slow][1]if flag:print("是回文链表!")else:print("不是回文链表!")A．①fast!=-1 or a[fast][1]!=-1①fast!=-1B．①fast!=-1 or a[fast][1]!=-1①a[fast][1]!=-1 C．①fast!=-1 and a[fast][1]!=-1①fast!=-1D．①fast!=-1 and a[fast][1]!=-1①a[fast][1]!=-1 7．有如下图所示的单向链表：从头指针head指向的节点开始查找数据元素“5”，并删除该节点，下列说法正确的是（）A．共需查找3次B．删除数据元素“5”的节点，后续节点需要移动3次C．头指针head将指向数据元素“7”的节点D．操作完成后，链表中数据元素的个数为6个8．创建一个空链表时，通常会设置什么来表示链表的起始（）A．尾指针B．头指针指向一个空节点C．头指针指向NULL或-1D．无需设置特殊标记9．一头指针head=2 的单向链表L=[[30,4], [10,-1], [20,0], [15,1],[21,3]]通过以下Python 程序段，转换为原链表的逆序链表，即头指针head=1，L=[[30,2], [10,3], [20,-1], [15,4],[21,0]]。
浙教版(2019)选修1《2
浙教版（2019）选修1《2.2 链表》2022年同步练习卷（2）1. 下列关于链表的说法，正确的是（ ）A. 链表中的各元素在存储空间中的位置必须是连续的B. 链表中的表头元素一定存储在其他元素的前面C. 链表中的各元素在存储空间中的位置不一定连续，且各元素存储顺序也是任意的D. 链表一旦创建好后，它的占用空间就是固定的2. 在一个包含n（n＞1）个节点的单链表上，没有头和尾两个指针，下列操作需要遍历多个节点的是（ ）A. 删除该链表中的第一个节点B. 删除该链表中的最后一个节点C. 在该链表第一个节点前插入一个新节点D. 在该链表最后一个节点后插入一个新节点3. 用Python的二维列表来模拟单向链表，已知列表a=[[“红”，1]，[“橙”，2]，[“绿”，3]，[“青”，-1]]，则在删除节点“橙”之后，列表a的值为（ ）A. [[“红”，1]，[“绿”，3]，[“青”，-1]]B. [[“红”，1]，[“绿”，2]，[“青”，-1]]C. [[“红”，1]，[“橙”，2]，[“绿”，3]，[“青”，-1]]D. [[“红”，2]，[“橙”，2]，[“绿”，3]，[“青”，-1]]4. 使用Python的二维列表来模拟单向链表，已知列表a=[[“红”，1]，[“绿”，2]，[“青”，-1]]，则在节点“红”和节点“绿”之间插入节点“橙”之后，列表a的值为（ ）A. [[“红”，3]，[“绿”，2]，[“青”，-1]，[“橙”，1]]B. [[“红”，1]，[“绿”，2]，[“青”，-1]，[“橙”，3]]C. [[“红”，1]，[“橙”，3]，[“绿”，2]，[“青”，-1]]D. [[“红”，1]，[“橙”，2]，[“绿”，3]，[“青”，-1]]5. 下列代码创建了一个拥有4个节点的双链表a：a=[[2，2，3]，[8，3，-1]，[0，-1，0]，[4，0，1]]head=2则其头节点和尾节点数据域的值分别为（ ）A. 2和4B. 0和8C. 8和0D. 3和-16. 有如下代码段：a=[[2，2，5]，[8，0，5]，[0，-1，0]，[1，-1，2]，[5，5，-1]，[3，0，-1]]head=2则该双向链表a的节点数量为（ ）A. 3B. 4C. 5D. 67. 有如下python程序段：a=[[7，1]，[8，2]，[9，-1]，[6，0]]head=3head=a[head][1]则程序执行后，链表a有几个节点（ ）A. 1B. 2C. 3D. 48. 有如下python程序段，表示一个链表及操作：a=[[5，-1]，[9，4]，[7，3]，[2，1]，[6，0]]head=2p=headb=[]While a[p][1]!=-1：b.append（a[p][0]）p=a[p][1]b.append（a[p][0]）print（b）程序执行后，输出的结果为（ ）A. [7，2，9，6，5，5]B. [5，9，7，2，6]C. [7，2，9，6，5]D. [2，9，6]9. 有python程序段：则程序运行后，a的值为（ ）A. [[1，1]，[2，2]，[3，3]，[4，-1]]B. [[1，-1]，[2，0]，[3，1]，[4，2]]C. [[4，1]，[3，2]，[2，3]，[1，-1]]D. [[4，-1]，[3，0]，[2，1]，[1，2]]10. 有如下python程序段：a=[[4，2，-1]，[0，-1，2]，[2，1，0]]head=1a.append（[8，-1，-1]）p=headwhile a[p][2]!=-1：p=a[p][2]a[p][2]=len（a）-1a[-1][1]=p上述代码段中的二维列表a看作是一个双向链表，则执行上述语句后，双向链表的结构可以表示为（ ）A. 4-＞0-＞2-＞8B. 8-＞4-＞0-＞2C. 0-＞2-＞4-＞8D. 8-＞0-＞2-＞411. 有如下python程序段：a=[[2，2，3]，[8，3，-1]，[0，-1，0]，[4，0，1]]head=2if a[head][2]!=-1：a[a[head][2]][1]=-1head=a[head][2]上述代码段中的二维列表a看作是一个双向链表，则执行上述语句后，双向链表的结构可以表示为（ ）A. 0-＞2-＞4-＞8B. 0-＞2-＞4C. 0-＞2-＞8D. 2-＞4-＞812. 十二生肖，又称属相，是中国与十二地支相配、表示人出生年份的十二种动物，包括“鼠牛虎兔龙蛇马羊猴鸡狗猪”，小美创建了一个单向链表，每个节点存储一个生肖名称，可是他漏掉了生肖鼠、生肖马和生肖猪。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
（2）下列程序的功能是实现向head指向的链表中插入新结点s，如图17所示，使该链表按结点的id值保持升序排列。
图17
#include<stdio.h>
#include<stdlib.h>
typedef struct Node{
int id;
char *name;
struct Node *next;
}Node;
void Innode(Node *head,int id,char *str) {
int j=0;
Node *p,*q,*s;
p=head;
while( ④) {
q=p;
p=p->next;
}
s=(Node*)malloc(sizeof(Node));
s->id=id;
s->name=str;
⑤
⑥
}
main()
{
/*省略创建链表head的代码*/ Innode(head,3,”Jone”);
}
36．Merge函数用于将两个升序的链表head1和head2合并成一个链表，并保持合并后链表依然升序。
排序的依据为结构体类型Node中的data成员，合并中不得删除节点。
下面给出Merge函数的主体框架,在空出的五个位置补充该主体框架缺失的代码段。
注意：不能定义新的变量，可不用已定义的某些变量。
typedef struct Node
{
int data；
struct Node *next；
}Node；
Node *Merge(Node *head1，Node *head2)
{
if ( head1==NULL)
return head2；
if(head2==NULL)
return headl；
Node *head=NULL；//head指针用于指向合并后链表的头结点
Node *pl=NULL；
Node *p2=NULL；
if(headl->data<head2->data){
head=headl；
______①______
p2=head2；
}else{
head=head2；
______②______
pl=headl；
}
}
Node *pcurrent=head；
while(p1!=NULL&&p2!=NULL) {
if(pl->data<=p2->data){
pcurrent->next=p1；
______③______
p1=pl->next；
}else{
pcurrent->next=p2；
______④______
p2=p2->next；
}
}
if(pl!=NULL)
______⑤______
if(p2!=NULL)
pcurrent->next=p2；return head；
}。