第三章 链表 基本题
链表c语言题

链表c语言题摘要:1.链表的概念和基本结构2.C 语言中链表的实现3.链表的操作及其应用4.链表的优势与局限性正文:一、链表的概念和基本结构链表是一种数据结构,它是由一系列节点组成,每个节点包含两个部分:数据域和指针域。
数据域用于存储数据,指针域则指向下一个节点。
链表的第一个节点称为头节点,最后一个节点称为尾节点。
链表可以根据需要动态增加或删除节点,因此具有很大的灵活性。
二、C 语言中链表的实现在C 语言中,链表的实现通常包括两个部分:链表结构体和链表操作函数。
链表结构体用于定义链表的节点,它包含数据域和指针域。
链表操作函数则负责实现链表的各种操作,如创建节点、插入节点、删除节点等。
以下是一个简单的链表结构体示例:```ctypedef struct Node {int data; // 数据域struct Node *next; // 指针域,指向下一个节点} Node;```三、链表的操作及其应用链表的操作主要包括创建节点、插入节点、删除节点等。
这些操作可以通过链表操作函数来实现。
以下是一些常见的链表操作示例:1.创建节点:```code *createNode(int data) {Node *newNode = (Node *) malloc(sizeof(Node));newNode->data = data;newNode->next = NULL;return newNode;}```2.插入节点:```cvoid insertNode(Node **head, int data) {Node *newNode = createNode(data);newNode->next = *head;*head = newNode;}```3.删除节点:```cvoid deleteNode(Node **head, int data) {Node *temp;if (*head == NULL) return;if ((*head)->data == data) {temp = *head;*head = (*head)->next;free(temp);return;}Node *prev = *head;while (prev->next!= NULL && prev->next->data!= data) { prev = prev->next;}if (prev->next == NULL) return;temp = prev->next;prev->next = temp->next;free(temp);}```四、链表的优势与局限性链表的优势在于它可以根据需要动态增加或删除节点,因此在存储动态数据时具有很大的灵活性。
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、下面程序执行后的输出结果是()。
顺序表链表题库

第三章顺序表一、填空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个元素的顺序存储结构的线性表中,若给定的是某个元素的关键字值,要访问该元素的其它信息的时间复杂度是()。
链表c语言经典例题

链表c语言经典例题
链表是计算机科学中的经典数据结构之一,常用于存储和操作动态数据。
以下是一些常见的链表例题,可以帮助理解链表的基本操作和应用。
1. 链表的创建:
- 创建一个空链表。
- 创建一个包含指定节点值的链表。
2. 链表的插入操作:
- 在链表的头部插入一个节点。
- 在链表的尾部插入一个节点。
- 在指定位置插入一个节点。
3. 链表的删除操作:
- 删除链表的头节点。
- 删除链表的尾节点。
- 删除指定数值的节点。
4. 链表的查找操作:
- 查找链表中指定数值的节点。
- 查找链表的中间节点。
5. 链表的逆序操作:
- 反转整个链表。
- 反转链表的前 N 个节点。
- 反转链表的一部分区间内的节点。
6. 链表的合并操作:
- 合并两个有序链表,使其有序。
- 合并 K 个有序链表,使其有序。
7. 链表的环检测:
- 判断链表中是否存在环,若存在,则返回环的起始节点。
8. 链表的拆分操作:
- 将一个链表按照奇偶位置拆分成两个链表。
以上是一些链表的经典例题,通过解答这些例题,可以加深对链表结构和基本操作的理解。
在编写对应的 C 语言代码时,需要注意链表节点的定义、指针的使用以及内存的动态分配和释放等问题。
链表常见的题型和解题思路

链表常见的题型和解题思路1.链表中环的⼊⼝节点⾸先判断头指针是不是空的然后需要判断这个链表中包不包含环:两个指针,⼀个⼀步⼀个两部,如果相遇,说明存在然后判断环节点的个数:从相遇的位置开始,往前⾛并计数,直到和⾃⼰再次相遇,得到个数然后找出⼊⼝节点:从头开始,俩指针⼀个先⾛n步,另⼀个再⾛,两个相遇的位置就是⼊⼝节点位置2.翻转链表需要判断链表是不是空的或者链表是不是只有⼀个节点,如果是的话,直接就输出原来的链表了;如果不是的话,翻转利⽤循环来做,因为需要将当前节点指向前⼀个节点,所以后⼀个节点需要先保存位置,也就是需要三个指针,⼀个pPre,⼀个pCur,⼀个pNext:先保存后⼀个节点,然后把当前节点指向前⼀个节点,然后把当前节点变成上⼀个节点,下⼀个节点变成当前节点;注意翻转之后头结点是原来的最后⼀个节点。
3.从尾到头打印链表思路(1):可以先翻转链表,再逐个输出思路(2):这种具有“后进先出”特性的,⽤栈⽐较容易,创建⼀个栈存放链表的节点,存放完之后从栈顶依次取出即可4.两个链表的第⼀个公共节点举例⼦:1 2 5 9 6 3 07 8 9 6 3 0⾸先需要知道的是,两个链表从公共节点开始,之后的节点肯定都是⼀模⼀样的;可以先遍历得到两个链表各⾃的长度,然后让长的那个先⾛⽐另⼀个长出的步数,再同时⾛,判断哪⾥相等哪⾥就是第⼀个公共节点了5.链表中倒数第k个节点单向链表肯定是不能从后往前数的,这个跟上⾯有的类似,既然知道是倒数第k个,那就两个指针,让⼀个先⾛k-1步,然后两个同时⾛,判断先⾛的那个到尾结点了,那后⾛的那个就是倒数第k个节点。
6.删除链表中重复的节点例如:1 2 3 3 4 4 5结果是1 2 5⾸先需要判断头指针(第⼀个节点)和第⼆个节点是不是空的,如果是,返回头指针就⾏了;正常情况的时候,因为有可能存在删除第⼀个节点的情况,所以需要先重新创建⼀个头指针ListNode* newHead = new ListNode(-1),然后把这个头指针赋初值指向原本的头指针newHead->next = pHead;然后需要三个指针来解决这个问题,分别是pPre pCur pNext三个,pPre 赋初值newHead,pCur赋初值pHead, 利⽤当前节点的循环来进⾏:得判断当前节点和当前节点的下⼀个节点不为空才进⼊循环来查找和删除,因为⾥头要对节点进⾏删除,所以要先保存下⼀个节点,然后如果当前节点等于下⼀个节点的值,因为还要继续判断下⼀位,来⼀个循环,只要下⼀个节点和当前节点的值相等,就把pNext往后移⼀个,直到找到不相等的就退出这个查找的循环了;然后执⾏删除,也就是把上⼀个节点pPre的下⼀个节点变成pNext,当前操作循环的节点变成pNext,然后再去循环判断;那如果当前节点和下⼀个节点的值不相等呢:指针往后挪,循环再判断,也就是pPre = pCur;pCur = pCur->next。
链表练习题及答案

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);。
数据结构(第二版)习题答案第3章

3.1 选择题第3章线性表的链式存储(1)两个有序线性表分别具有n个元素与m个元素且n≤m,现将其归并成一个有序表,其最少的比较次数是( A )。
A.n B.m C.n− 1D.m + n(2)非空的循环单链表head 的尾结点(由p 所指向)满足( C )。
A.p->next==NULL B.p==NULL C.p->next==head D.p==head (3)在带头结点的单链表中查找x应选择的程序体是( C )。
A.node *p=head->next; while (p && p->info!=x) p=p->next;if (p->info==x) return p else return NULL;B.node *p=head; while (p&& p->info!=x) p=p->next; return p;C.node *p=head->next; while (p&&p->info!=x) p=p->next; return p;D.node *p=head; while (p->info!=x) p=p->next ; return p;(4)线性表若采用链式存储结构时,要求内存中可用存储单元的地址( D )。
A.必须是连续的C.一定是不连续的B.部分地址必须是连续的D.连续不连续都可以(5)在一个具有n个结点的有序单链表中插入一个新结点并保持单链表仍然有序的时间复杂度是( B )。
A.O(1) B.O(n) C.O(n2) D.O(n log2n)(6)用不带头结点的单链表存储队列时,其队头指针指向队头结点,其队尾指针指向队尾结点,则在进行删除操作时( D )。
A.仅修改队头指针C.队头、队尾指针都要修改B.仅修改队尾指针D.队头,队尾指针都可能要修改(7)若从键盘输入n个元素,则建立一个有序单向链表的时间复杂度为( B )。
课堂练习题---链表

1、设单链表中指针P指着结点A ,若要删除A之后结点(若存在),则需要修改指针的操作为()。
A. p->next=p->next->nextB. p=p->nextC. p=p->next->nextD. P->next=p8.从一个具有n个节点的单链表中查找其值等于x结点时,在查找成功的情况下,需平均比较个结点。
A. nB. n/2C. (n-1)/2D. (n+1)/22.在一个单链表中,已知*q结点是*p结点的前驱结点,若在*q和*p之间插入*s 结点,则执行。
A. s->next=p->next; p->next=s;B. p->next=s->next; s->next=p;C. q->next=s; s->next=p;D. p->next=s; s->next=q;3.线性表采用链式存储时,其地址。
A. 必须是连续的B.部分地址必须是连续的C. 一定是不连续的D. 连续与否均可以4.设单链表中指针p指着结点(数据域为m),指针f指着将要插入的新结点(数据域为x),当x插在结点m之后时,只要先修改后修改p->link=f即可。
A. f->link=p;B. f->link=p->link;C. p->link=f->link;D. f=nil;5.在双向链表存储结构中,删除p所指的结点时需修改指针。
A. ((p->rlink) ->rlink) ->link=p; p->rlink=(p->rlink) ->rlink;B. (p->llink) ->rlink=p->rlink; (p->rlink) ->llink=p->llink;C. p->llink=(p->llink) ->llink; ((p->llink) ->llink) ->rlink=p;D. ((p->llink) ->llink) ->rlink=p; p->llink=(p->llink) ->llink;6.在双向链表存储结构中,删除p所指的结点的前趋结点(若存在)时需修改指针。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
第三章链表基本题3.2.1单项选择题1.不带头结点的单链表head为空的判定条件是A.head=NULLB.head->next=NULLC.head->next=headD.head!=NULL2.带头接待点的单链表head为空的判定条件是A.head=NULLB.head->next=NULLC.head->next=headD.head!=NULL3.非空的循环单链表head的尾结点(由p所指向)满足A.p->head=NULLB.p=NULLC.p->next=headD.p=head4.在循环双链表p的所指结点之后插入s所指结点的操作是A.p->right=s; s->left=p; p->right->lefe=s; s->right=p->right;B.p->right=s; p->right->left=s; s->lefe=p; s->right=p->right;C.s->lefe=p; s->right=p->right; p->right=s; p->right->left=s;D.s->left=p; s->right=p->right; p->right->left=s; p->right=s;5.在一个单链表中,已知q所指结点是所指结点p的前驱结点,若在q和p之间插入结点S,则执行A.s->next=p->next; p->next=s;B.p->next=s->next; s->next=p;C.q->next=s; s->next=p;D.p->next=s; s->next=q;6.在一个单链表中,若p所指结点不是最后结点,在p之后插入s所指结点,则执行A.s->next=p; p->next=s;B.s->next=p->next; p->next=s;C.s->next=p->next; p=s;D.p->next=s; s->next=p;7.在一个单链表中,若删除p所指结点的后续结点,则执行A.p->next=p->next->next;B.p=p->next; p->next=p->next->next;C.p->next=p->nextD.p=p->next->next8.假设双链表结点的类型如下:typedef struct linknode{int data; /*数据域*/Struct linknode *llink; /*llink是指向前驱结点的指针域*/Struct linknode *rlink; /*rlink是指向后续结点的指针域*/}bnode下面给出的算法段是要把一个所指新结点作为非空双向链表中的所指结点的前驱结点插入到该双链表中,能正确完成要求的算法段是A.q->rling=p; q->llink=p->llink; p->llink=q;p->llink->rlink=q;B.p->llink=q; q->rlink=p; p->llink->rlink=q; q->llink=p->llink;C.q->llink=p->llink; q->rlink=p; p->llink->rlink=q; p->llink=q;D.以上都不对9.从一个具有n个结点的有序单链表中查找其值等于x结点时,在查找成功的情况下,需平均比较()个结点。
A.nB.n/2C.(n-1)/2D.O(n㏒2n)10.给定有n个元素的向量,建立一个有序单链表的时间复杂A.O(1)B.O(n)C.O(n2)D.O(n㏒2n)11.在一个具有n个结点的有序单链表中插入一个新结点并仍然有序的时间复杂度是A.O(1)B.O(n)C.O(n2)D.O(n㏒2n)12.向一个栈顶指针为HS的链栈中插入一个s所指结点时,则执行A.HS->next=s;B.s->next=HS->next; HS->next=s;C.s->next=HS; HS=s;D.s->next=HS; HS=HS->next13.从一个栈顶指针为HS的链栈中删除一个结点时,用x保存被删除结点的值,则执行A.x=HS; HS=HS->next;B.x=HS->data;C.HS=HS->next; x=HS->data;D.x=HS->data; HS=HS->next;14.在一个链队中,假设f和r分别为队首和队尾指针,则插入s所指结点的运算是A.f->next=s; f=s;B.r->next=s; r=s;C.s->next=r;r=s;D.s->next=f; f=s;15.在一个链队中,假设f和r分队为队首和队尾指针,则删除一个结点的运算是A.r=f->next;B.r=r->next;C.f=f->next;D.f=r->next;3.2.2填空题1.单链表是()的连接存储表示。
2.可以使用()表示树型结构。
3.在双链表中,每个结点有两个指针域,一个指向(1),另一个指向(2)。
4.在一个单链表中的所指结点之前插入一个所指结点时,可执行如下操作:s->next=(1); p->next=s; t=p->data; p->data=(2); s->data=(3);5.在一个单链表中删除p所指结点时,应执行如下操作:q=p->next; p->data=p->next->data; p->next=( ); free(q);6.带有一个头结点的单链表head为空的条件是( ).7.在一个单链表中p所指结点之后插入一个s所指结点时,应执行s->next=(1)和p->next=(2)的操作。
8.非空的循环单链表head的尾结点(由p所指向),满足条件()。
9 在栈顶指针为HS的链栈中,判定栈空的条件是()。
10.在栈顶指针为HS的链栈中,计算该链栈中结点个数的函数是()。
11.在HQ的链队中,判定只有一个结点的条件是()。
12.在HQ的链队中,计算该链队中结点个数的函数是( )。
13.对于一个具有n个节点的单链表 ,在已知所指结点后插入一个新结点的时间复杂度是(1);在给定值为的结点后插入一个新结点的时间复杂度是(2)。
3.2基本题答案3.2.1单项选择题答案1.A2.B3.C4.D5.C6.B7.A8.C9.D 10.B 11.C 12.C 13.D 14.B 15.C 3.2.2填空题答案1.线性表2.双链表3.(1)前驱结点(2)后续结点4.(1)p->next (2)s->data (3)t5.p->next->next6.head->nxet=NULL7.(1)p->next (2)s8.head->next=p9.HS==NULL 10.int count(HS)Node *HS;{node *p;Int n=0;P=HS;While(p!=NULL){n++;P=p->next;}Return(n);}11.HQ->front==HQ->rear12.int count(HQ)Struct linkqueue *HQ;{struct linkqueue *p;Int n;P=HQ->first;If(p==NULL) return(0);n=1;while(p!=HQ->rear){n++;P=p->next;}return(n);}13.(1)O(1) (2)O(n)3.3习题解析1. 线性表可用顺序表或链表存储。
试问:(1) 两种存储表示各有哪些主要优缺点?(2) 如果有n个表同时并存,并且在处理过程中各表的长度会动态发生变化,表的总数也可能自动改变、在此情况下,应选用哪种存储表示?为什么?(3) 若表的总数基本稳定,且很少进行插入和删除,但要求以最快的速度存取表中的元素,这时,应采用哪种存储表示?为什么?【解答】(1) 顺序存储表示是将数据元素存放于一个连续的存储空间中,实现顺序存取或(按下标)直接存取。
它的存储效率高,存取速度快。
但它的空间大小一经定义,在程序整个运行期间不会发生改变,因此,不易扩充。
同时,由于在插入或删除时,为保持原有次序,平均需要移动一半(或近一半)元素,修改效率不高。
链接存储表示的存储空间一般在程序的运行过程中动态分配和释放,且只要存储器中还有空间,就不会产生存储溢出的问题。
同时在插入和删除时不需要保持数据元素原来的物理顺序,只需要保持原来的逻辑顺序,因此不必移动数据,只需修改它们的链接指针,修改效率较高。
但存取表中的数据元素时,只能循链顺序访问,因此存取效率不高。
(2) 如果有n个表同时并存,并且在处理过程中各表的长度会动态发生变化,表的总数也可能自动改变、在此情况下,应选用链接存储表示。