链表试题算法汇总
单链表、双链表、循环链表和静态链表的习题
单链表、双链表、循环链表和静态链表的习题一、单项选择题1.关于线性表的顺序存储结构和链式存储结构的描述中,正确的是()。
Ⅰ.线性表的顺序存储结构优于其链式存储结构Ⅱ.链式存储结构比顺序存储结构能更方便地表示各种逻辑结构Ⅲ.如频繁使用插入和删除结点操作,顺序存储结构更优于链式存储结构Ⅳ.顺序存储结构和链式存储结构都可以进行顺序存取A. Ⅰ、Ⅱ、ⅢB. Ⅱ、ⅣC. Ⅱ、ⅢD. Ⅲ、Ⅳ2.对于一个线性表既要求能够进行较快速地插入和删除,又要求存储结构能反映数据之间的逻辑关系,则应该用()。
A.顺序存储方式B.链式存储方式C.散列存储方式D.以上均可以3.对于顺序存储的线性表,其算法的时间复杂度为O(1)的运算应该是()。
A.将n个元素从小到大排序B.删除第i个元素(1<i<n)C.改变第i个元素的值(1<=i<=n)D.在第i个元素后插入一个新元素(1<=i<=n)4.下列关于线性表说法正确的是()。
Ⅰ.顺序存储方式只能用于存储线性结构Ⅱ.取线性表的第i个元素的时间同i的大小有关Ⅲ.静态链表需要分配较大的连续空间,插入和删除不需要移动元素Ⅳ.在一个长度为n的有序单链表中插入一个新结点并仍保持有序的时间复杂度为O(n) Ⅴ.若用单链表来表示队列,则应该选用带尾指针的循环链表A. Ⅰ、ⅡB.Ⅰ、Ⅲ、Ⅳ、ⅤC. Ⅳ、ⅤD. Ⅲ、Ⅳ、Ⅴ5.设线性表中有2n个元素,()在单链表上实现要比在顺序表上实现效率更高。
A.删除所有值为x的元素B.在最后一个元素的后面插入一个新元素C.顺序输出前k个元素D.交换第i个元素和第2n-i-l个元素的值(i=0,…, n-1)6.在一个单链表中,已知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;7.给定有n个元素的一维数组,建立一个有序单链表的最低时间复杂度是()。
算法设计练习题
算法设计练习题1、设一棵二叉树以二叉链表为存储结构,结点结构为。
设计一个算法,求在前根序列中处于第k个位置的结点。
2、设某单链表L的结点结构为编写算法判断该链表的元素是否是递增的。
3、设有一单链表L,结点结构为3个,试画出链表L的结构图,并编写算法判断该单链表L中的元素是否成等差关系,即:设各元素值次为a1,a2,a3,…,a n,判断a i+1-a i=a i-a i-1是否成立,其中i满足2<=i<=n-1.4、设有一棵二叉树以二叉链表作为存储结构,结点结构为其中data数字的字符(即‘0’<=data<=‘9’)5、写出一个在带头结点的单链表上删除表中第i个结点的算法。
单链表的结点类型及单链表类型定义:typedef struct node{ DataType data;struct node *next;}Node, *LinkList;6、给出求二叉树的结点数的算法。
二叉树的二叉链表存储表示:typedef struct BiTNode{ DataType data;struct BiTNode *lchild,*rchild;}BiTNode, *BiTree;7. 写出一个删除单链表的表头结点和表尾结点的算法。
单链表的结点类型及单链表类型定义:typedef struct node{ DataType data;struct node *next;}Node, *LinkList;8、已知一带头结点的单链表,由头指针H指向,其结点的类型如下:typedef struct node{ elemtype data;struct node *next;}NODE,*NODEPTR;现要在链表中删除其关键字为aidkey的结点,其程序如下:int deletelm(NODEPTR H,keytype aidkey)/*若删除成功,则返回1,否则返回0*/{ NODEPTR pre,p;pre=H;p=H->next;while(p&&p->data.key!=aidkey){ pre=p;①;}if(p){ ②;free(p);return 1;}else return 0;}9、已知待排序的线性表的结构定义如下:#define MAXSIZE 200typedef int keytype;typedef struct{ keytype key;othertype other;}redtype;typedef struct{ redtype r[MAXSIZE];int length;}sqlist;其中L->r[0]用于作临时单元,数据从L->r[1]开始存放。
顺序表链表题库
第三章顺序表一、填空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、已知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);。
数据结构链表习题
练习题:1)在一个单链表head中,若要在指针p所指结点后插入一个q指针所指结点,则执行_____。
A. p->next=q->next; q->next=p;B. q->next=p->next; p=q;C. p->next=q->next; p->next=q;D. q->next=p->next; p->next=q;2)在一个单链表head中,若要删除指针p所指结点的后继结点,则执行_____。
A. p=p->next;free(p);B. p->next=p->next->next; free(p);C. q= p->next ;q->next=p->next; free(q);D. q=p->next; p->next=q->next ;free(q);3)若长度为n的线性表(a1, a2,…, a n)采用顺序存储,在第i个位置上插入一个新元素,需要依次向后移动个数据元素。
A n-iB n-i-1C n-i+1D n+i3)完成下列打印带头单链表的各元素的算法.typedef struct List{ int data;struct List *next;} Node,*Link;void printlk(Link head){Link p=head->next;{ printf(“%d\n”,p->data);}4)已知无头单链表A和B表示两个集合,本算法实现A=A-B (集合的补运算)。
typedef struct node {int data;struct node *next;}lnode;void setminus(lnode *&A,lnode *B)while (B!=NULL){p=A;}A=A->next;}5)下列算法创建n个元素的带头单链表.typedef struct lnode { int data;struct lnode *next;}lnode,*linklist ;void create(linklist &head, int n){linklist p; int i;head=(linklist)malloc(sizeof(lnode));A head->next=nullfor(i=n;i>0;i--){p =(linklist)malloc(sizeof(lnode));scanf(“%d”,&p->data);B p->next=head->nextC head->next=p}}。
数据结构与算法面试题
数据结构与算法面试题目录1. 数组 (3)2. 链表 (5)3. 栈 (9)4. 队列 (10)5. 堆(优先队列) (12)6. 二叉树 (15)7. 二叉查找树 (24)8. 字典树 (26)9. 平衡树(AVL) (26)10. 红黑树 (26)11. B树/B+树 (28)12. 哈希 (29)13. 图 (31)14. 字符串 (33)15. 排序 (36)16. 二分查找 (40)17. 跳跃列表 (41)18. 动态规划 (42)1.数组应用场景:1)数据比较少2)经常做的运算是按序号访问数据元素面试题选择题:1)对于长度为n的线性表,建立其对应的单链表的时间复杂度为()。
O(1)O(log2n)O(n)O(n^2)2)下列哪些不是线性表?队列栈关联数组链表3)稀疏矩阵一般的压缩存储方法有两种,即()二维数组和三维数组三元组和散列三元组和十字链表散列和十字链表4)将10阶对称矩阵压缩存储到一维数组A中,则数组A的长度最少为1004055805)设A是n*n的对称矩阵,将A的对角线及对角线上方的元素以列为主的次序存放在一维数组B[1..n(n+1)/2]中,对上述任一元素aij (1≤i,j≤n,且i≤j)在B中的位置为()i(i-1)/2+jj(j-1)/2+ij(j-1)/2+i-1i(i-1)/2+j-16)若有定义:int c[4][5],( *pc)[5];pc=c;那么,下列对数组C的元素引用正确的是( )。
pc+1* (pc+3)* (pc+1) +3* (*pc+2)问答题:1)数组和链表的区别思路:从逻辑结构上来看,数组必须实现定于固定的长度,不能适应数据动态增减的情况,即数组的大小一旦定义就不能改变。
当数据增加是,可能超过原先定义的元素的个数;当数据减少时,造成内存浪费;链表动态进行存储分配,可以适应数据动态地增减的情况,且可以方便地插入、删除数据项。
从内存存储的角度看;数组从栈中分配空间(用new则在堆上创建),对程序员方便快速,但是自由度小;链表从堆中分配空间,自由度大但是申请管理比较麻烦。
c++数据结构链表的选择题
c++数据结构链表的选择题
摘要:
1.链表的定义与特点
2.链表的种类
3.链表的优缺点
4.选择题解答
正文:
一、链表的定义与特点
链表是一种数据结构,它是由一系列节点组成,每个节点包含两个部分:数据部分和指针部分。
数据部分用于存储数据,指针部分用于指向下一个节点。
链表的第一个节点称为头节点,最后一个节点称为尾节点。
链表的特点是每个节点之间通过指针进行连接,而且每个节点都可以随时删除或插入。
二、链表的种类
链表主要有两种类型:单链表和双链表。
单链表只有一个指针域,它只能指向下一个节点;双链表有两个指针域,一个指向前一个节点,一个指向后一个节点。
双链表在插入和删除操作时比单链表更加方便。
三、链表的优缺点
链表的优点是插入和删除操作比较灵活,不需要移动元素,时间复杂度为O(1)。
链表的缺点是存储空间利用率较低,每个节点需要额外的指针空间。
另外,链表的访问速度较慢,因为需要遍历整个链表才能找到目标节点。
算法练习题
算法练习题一、基础算法1. 编写一个程序,实现一个冒泡排序算法。
2. 实现一个选择排序算法。
3. 实现一个插入排序算法。
4. 编写一个函数,计算一个整数数组中的最大值和最小值。
5. 编写一个函数,实现二分查找算法。
6. 编写一个函数,实现快速排序算法。
7. 编写一个函数,判断一个整数是否为素数。
8. 编写一个函数,实现反转一个整数数组。
9. 编写一个函数,计算两个整数数组的交集。
10. 编写一个函数,判断一个字符串是否为回文。
二、数据结构11. 实现一个单链表的基本操作,包括插入、删除、查找。
12. 实现一个双向链表的基本操作,包括插入、删除、查找。
13. 实现一个栈的基本操作,包括压栈、出栈、查看栈顶元素。
14. 实现一个队列的基本操作,包括入队、出队、查看队首元素。
15. 实现一个二叉树的基本操作,包括插入、删除、查找。
16. 实现一个二叉搜索树的基本操作,包括插入、删除、查找。
17. 实现一个哈希表的基本操作,包括插入、删除、查找。
三、搜索与图论18. 编写一个程序,实现深度优先搜索(DFS)算法。
19. 编写一个程序,实现广度优先搜索(BFS)算法。
20. 编写一个程序,求解迷宫问题。
21. 编写一个程序,计算一个有向图的拓扑排序。
22. 编写一个程序,计算一个无向图的欧拉回路。
23. 编写一个程序,计算一个加权无向图的最小树(Prim算法)。
24. 编写一个程序,计算一个加权有向图的最短路径(Dijkstra算法)。
25. 编写一个程序,计算一个加权有向图的所有顶点对的最短路径(Floyd算法)。
四、动态规划26. 编写一个程序,实现背包问题。
27. 编写一个程序,计算最长公共子序列(LCS)。
28. 编写一个程序,计算最长递增子序列(LIS)。
29. 编写一个程序,实现编辑距离(Levenshtein距离)。
30. 编写一个程序,实现硬币找零问题。
31. 编写一个程序,实现矩阵链乘问题。
C语言链表题目及答案
下面哪种选项描述了链表的特点?A) 可以随机访问元素B) 拥有固定大小的内存空间C) 元素之间通过指针连接D) 可以自动调整大小答案: C在链表中,头节点的作用是什么?A) 存储链表的长度B) 存储链表的最后一个节点C) 存储链表的第一个节点D) 存储链表的中间节点答案: C下面哪种选项描述了双向链表的特点?A) 每个节点只有一个指针指向下一个节点B) 每个节点只有一个指针指向上一个节点C) 每个节点同时拥有指向前一个节点和后一个节点的指针D) 只能从链表的一端进行操作答案: C在链表中,删除一个节点的操作涉及修改哪些指针?A) 只需要修改被删除节点的前一个节点的指针B) 只需要修改被删除节点的后一个节点的指针C) 需要修改被删除节点的前一个节点和后一个节点的指针D) 不需要修改任何指针答案: C在链表的尾部添加一个新节点的操作复杂度是多少?A) O(1)B) O(n)C) O(log n)D) O(n^2)答案: A如何遍历链表的所有节点?A) 使用for循环B) 使用while循环C) 使用递归函数D) 使用if语句答案: B在链表中,如何找到特定值的节点?A) 使用线性搜索B) 使用二分搜索C) 使用递归搜索D) 使用栈搜索答案: A链表和数组相比,哪个更适合频繁插入和删除操作?A) 链表B) 数组C) 二叉树D) 堆栈答案: A在链表中,如何在指定位置插入一个新节点?A) 修改前一个节点的指针B) 修改后一个节点的指针C) 修改当前节点的指针D) 不需要修改任何指针答案: A链表的头指针指向什么?A) 链表的第一个节点B) 链表的最后一个节点C) 链表的中间节点D) 链表的空节点答案: A链表中节点的个数称为什么?A) 链表的长度B) 链表的高度C) 链表的宽度D) 链表的容量答案: A在链表中,如何删除指定值的节点?A) 修改前一个节点的指针B) 修改后一个节点的指针C) 修改当前节点的指针D) 不需要修改任何指针答案: A单链表的最后一个节点指向什么?A) 链表的第一个节点B) 链表的最后一个节点C) NULLD) 链表的中间节点答案: C双向链表相比于单向链表的优势是什么?A) 占用更少的内存空间B) 遍历速度更快C) 可以从任意方向遍历D) 插入和删除操作更快答案: C在链表中,如何找到倒数第n个节点?A) 遍历整个链表B) 使用递归函数C) 使用栈数据结构D) 使用双指针技巧答案: D链表的删除操作和数组的删除操作的时间复杂度分别是什么?A) 链表的删除操作为O(1),数组的删除操作为O(n)B) 链表的删除操作为O(n),数组的删除操作为O(1)C) 链表的删除操作为O(n),数组的删除操作为O(n)D) 链表的删除操作为O(1),数组的删除操作为O(1)答案: A在链表中,如何判断链表是否为空?A) 检查头指针是否为NULLB) 检查尾指针是否为NULLC) 检查链表的长度是否为0D) 检查链表的第一个节点是否为NULL答案: A链表的逆序操作是指什么?A) 删除链表中的节点B) 反转链表中节点的顺序C) 插入节点到链表的尾部D) 在链表中查找指定值的节点答案: B在链表中,如何查找指定值的节点?A) 使用线性搜索B) 使用二分搜索C) 使用递归搜索D) 使用栈搜索答案: A在双向链表中,如何删除指定值的节点?A) 修改前一个节点的指针B) 修改后一个节点的指针C) 修改当前节点的指针D) 不需要修改任何指针答案: A链表的插入操作和数组的插入操作的时间复杂度分别是什么?A) 链表的插入操作为O(1),数组的插入操作为O(n)B) 链表的插入操作为O(n),数组的插入操作为O(1)C) 链表的插入操作为O(n),数组的插入操作为O(n)D) 链表的插入操作为O(1),数组的插入操作为O(1)答案: A如何删除单向链表中的重复节点?A) 使用递归算法B) 使用双指针技巧C) 使用栈数据结构D) 不需要额外操作,链表会自动去重答案: B链表的优势之一是什么?A) 随机访问速度快B) 占用内存空间少C) 插入和删除操作高效D) 支持高级操作如排序和搜索答案: C在链表中,如何找到中间节点?A) 遍历整个链表B) 使用递归函数C) 使用栈数据结构D) 使用快慢指针技巧答案: D在链表中,如何在尾部添加一个新节点?A) 修改前一个节点的指针B) 修改后一个节点的指针C) 修改当前节点的指针D) 创建一个新节点并更新尾指针答案: D链表的查找操作的时间复杂度是多少?A) O(1)B) O(log n)C) O(n)D) O(n^2)答案: C在双向链表中,如何找到倒数第n个节点?A) 从头节点开始遍历B) 从尾节点开始遍历C) 使用递归函数D) 使用双指针技巧答案: B链表的删除操作的时间复杂度是多少?A) O(1)B) O(log n)C) O(n)D) O(n^2)答案: A链表和数组相比,哪个更适合频繁插入和删除操作?A) 链表B) 数组C) 哈希表D) 栈答案: A如何判断链表是否有环?A) 使用线性搜索B) 使用递归算法C) 使用快慢指针技巧D) 使用栈数据结构答案: C在链表中,如何反转链表的顺序?A) 使用递归算法B) 使用栈数据结构C) 使用双指针技巧D) 使用循环迭代答案: D在链表中,如何删除所有节点?A) 依次删除每个节点B) 修改头指针为NULLC) 修改尾指针为NULLD) 不需要额外操作,链表会自动清空答案: A链表的头节点是什么?A) 链表的第一个节点B) 链表的最后一个节点C) 链表的中间节点D) 链表的空节点答案: A在链表中,如何插入一个新节点到指定位置之前?A) 修改前一个节点的指针B) 修改后一个节点的指针C) 修改当前节点的指针D) 不需要修改任何指针答案: A在链表中,如何删除指定位置的节点?A) 修改前一个节点的指针B) 修改后一个节点的指针C) 修改当前节点的指针D) 不需要修改任何指针答案: A单向链表和双向链表的区别是什么?A) 单向链表只有一个指针指向下一个节点,双向链表有两个指针分别指向前一个节点和后一个节点B) 单向链表只能从头到尾遍历,双向链表可以从头到尾或者从尾到头遍历C) 单向链表只能在尾部添加节点,双向链表可以在头部和尾部都添加节点D) 单向链表只能包含整型数据,双向链表可以包含任意类型的数据答案: A链表的删除操作和数组的删除操作的时间复杂度分别是什么?A) 链表的删除操作为O(1),数组的删除操作为O(n)B) 链表的删除操作为O(n),数组的删除操作为O(1)C) 链表的删除操作为O(n),数组的删除操作为O(n)D) 链表的删除操作为O(1),数组的删除操作为O(1)答案: A如何判断两个链表是否相交?A) 比较链表的长度是否相等B) 比较链表的头节点是否相等C) 比较链表的尾节点是否相等D) 比较链表中的所有节点是否相等答案: B链表和数组的主要区别是什么?A) 链表是一种线性数据结构,数组是一种非线性数据结构B) 链表的长度可变,数组的长度固定C) 链表支持随机访问,数组只能顺序访问D) 链表的插入和删除操作效率高,数组的访问效率高答案: B在链表中,如何找到倒数第k个节点?A) 从头节点开始遍历,直到倒数第k个节点B) 从尾节点开始遍历,直到倒数第k个节点C) 使用递归函数查找倒数第k个节点D) 使用双指针技巧,一个指针先移动k步,然后两个指针同时移动直到第一个指针到达链表末尾答案: D在链表中,如何判断是否存在环?A) 使用线性搜索,检查是否有重复的节点B) 使用递归算法,判断节点是否已经访问过C) 使用栈数据结构,检查节点是否已经入栈D) 使用快慢指针技巧,如果两个指针相遇,则存在环答案: D如何将两个有序链表合并成一个有序链表?A) 创建一个新链表,依次比较两个链表的节点并插入新链表中B) 将第一个链表的尾节点指向第二个链表的头节点C) 将第二个链表的尾节点指向第一个链表的头节点D) 使用递归算法,依次比较两个链表的节点并合并答案: A在链表中,如何删除重复的节点?A) 使用递归算法,遍历链表并删除重复的节点B) 使用双指针技巧,依次比较相邻节点并删除重复的节点C) 使用栈数据结构,检查节点是否已经入栈并删除重复的节点D) 不需要额外操作,链表会自动去重答案: B链表的优点是什么?A) 占用内存空间少B) 插入和删除操作高效C) 支持高级操作如排序和搜索D) 可以随机访问任意位置的元素答案: B。
数据结构算法设计题及答案
数据结构算法设计题及答案1、对带表头结点的有序单链表,编写算法向单链表中插入元素x,使其保持有序。
答案:typedef datatype int;struct node //结点结构{ datatype data;node * next;};//注:也可以用自然语言描述void insertOrder(node *head, datatype x) //统计{ node *s;p=head;while (p->next ->data<x)p=p->next;s=( node *)malloc(sizeof(node)) ;s->data=x;s->next= p->next;p->next=s;}2、对带表头结点的单链表,编写算法求单链表的长度。
答案:typedef datatype int;struct node //结点结构{ datatype data;node * next;};//注:也可以用自然语言描述int Length(node *head) // 求单链表的长度{ int num=0;node *p=head->next;while (p){num++ ;p=p->next;}return num;}3、试写出单链表的插入与删除算法,并用C编写相应的程序。
答案:typedef datatype int;struct node //结点结构{ datatype data;node * next;};单链表的插入参考算法://在包含元素x的结点前插入新元素bvoid ins_linked_LList(node * head , datatype x, datatype b) { node *p, *q;p=new node ;//申请一个新结点p->d=b;//置新结点的数据域if (head==NULL)//原链表为空{ head=p; p->next=NULL; return;}if (head->d==x)//在第一个结点前插入{ p->next=head;head=p;return; }q=head;while ((q->next!=NULL)&&(((q->next)->d)!=x))q=q->next;//寻找包含元素x的前一个结点qp->next=q->next;q->next=p;//新结点p插入到结点q之后return;}单链表的删除参考算法:int del_linked_LList(node * head ,T x) //删除包含元素x的结点元素{ node *p, *q;if (head==NULL) return(0); //链表为空,无删除的元素if ((head->d)==x)//删除第一个结点{ p=head->next; delete head; head=p; return(1); }q=head;while ((q->next!=NULL)&&(((q->next)->d)!=x))q=q->next;//寻找包含元素x的前一个结点qif (q->next==NULL)return(0); //链表中无删除的元素p=q->next; q->next=p->next;//删除q的下一个结点pdelete p;//释放结点p的存储空间return(1);}4、对带表头结点的单链表,编写算法统计单链表中大于x的元素个数。
(完整版)数据结构与算法试题
一、选择题1. 在逻辑上能够把数据结构分红(A)A. 线性结构和非线性结构B. 动向结构和静态结构C.紧凑结构和非紧凑结构D.内部结构和外面结构2. 单链表中各结点之间的地点(C)A. 一定连续B.部分一定连续C.不必定连续D.以上均不对3. 在一个长度为 n 的次序表中向第 i 个元素( 0<i<=n+1 )以前插入一个新元素时,需向后挪动(B )个元素。
A 、n-iB、n-i+1C、n-i-1D、 i4. 插入和删除操作只好在一端进行的线性表,称为(C )。
A. 行列B. 线性表C. 栈D.循环行列5、行列是仅同意在()进行插入,而在()进行删除。
(A )A. 队尾,队首B. 队尾,队尾C. 队首,队尾D. 队首,队首6. 链表合适于(A )查找。
A. 次序B.二分C.随机D.次序或二分7. 数据的基本单位是(A )。
A. 数据元素B.数据结构C.数据项D.数据对象8. 以下哪个不是算法的特征(B )。
A. 有穷性B. 可数性C.可行性D.确立性9. 在表长为 n 的次序表中进行线性查找,它的均匀查找长度为(B )。
A.ASL=nB.ASL=(n+1)/2C.ASL=n+1 D.ASL=log2n10. 一个线性表第一个元素的储存地点是 320,每个元素的长度为 3,则第五个元素的地点是(C )。
11. 设 front 、rear 分别为循环双向链表结点的左指针和右指针,则指针 P 所指的元素是双循环链表 L 的尾元素的条件是(D )。
A.P==LB.P->front==LC.P==NULLD.P->rear==L12. 已知 P 为单链表中的非首尾结点,删除 P 结点的后继结点 Q 的语句为(A )。
A.P->NEXT=Q->NEXT;FREE(Q);B.Q->NEXT=P; FREE(Q);C.Q->NEXT=P->NEXT;FREE(Q);D.P->NEXT=S;S->NEXT=P; B第1页共16页 1A.SQ->rear==SQ->frontB. (SQ->rear+1)%MAXLEN==SQ->frontC.SQ->rear==0D. SQ->front==014. 一组记录的排序码为( 46, 79,56, 38, 40, 84),则利用堆排序的方法成立的初始堆 为(B )。
算法例题
算法例题1.假设有两个按元素值递增次序排列的线性表,均以单链表形式存储。
请编写算法将这两个单链表归并为一个按元素值递减次序排列的单链表,并要求利用原来两个单链表的结点存放归并后的单链表。
答: [题目分析]因为两链表已按元素值递增次序排列,将其合并时,均从第一个结点起进行比较,将小的链入链表中,同时后移链表工作指针。
该问题要求结果链表按元素值递减次序排列。
故在合并的同时,将链表结点逆置。
LinkedList Union(LinkedList la,lb)∥la,lb分别是带头结点的两个单链表的头指针,链表中的元素值按递增序排列,本算法将两链表合并成一个按元素值递减次序排列的单链表。
{ pa=la->next; pb=lb->next;∥pa,pb分别是链表la和lb的工作指针la->next=null; ∥la作结果链表的头指针,先将结果链表初始化为空。
while(pa!=null && pb!=null) ∥当两链表均不为空时作if(pa->data<=pb->data){ r=pa->next; ∥将pa 的后继结点暂存于r。
pa->next=la->next; ∥将pa结点链于结果表中,同时逆置。
la->next=pa;pa=r; ∥恢复pa为当前待比较结点。
}else{r=pb->next; ∥ 将pb 的后继结点暂存于r。
pb->next=la->next; ∥将pb结点链于结果表中,同时逆置。
la->next=pb;pb=r; ∥恢复pb为当前待比较结点。
}while(pa!=null) ∥将la表的剩余部分链入结果表,并逆置。
{r=pa->next; pa->next=la->next; la->next=pa; pa=r; }while(pb!=null){r=pb->next; pb->next=la->next; la->next=pb; pb=r; }}∥算法Union结束。
c语言链表指针编程题
以下是一个使用链表和指针的 C 语言编程题:题目:将一个无序整数数组按照升序排列,并存储在链表中。
要求:1.定义一个链表节点结构体,包含一个整数和一个指向下一个节点的指针。
2.实现一个函数,将无序整数数组按照升序排列,并将结果存储在链表中。
3.实现一个函数,遍历链表并输出每个节点的值。
示例:输入:复制代码无序整数数组:[3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]输出:复制代码链表节点值:[1, 1, 2, 3, 3, 4, 5, 5, 5, 6, 9]以下是一个可能的实现:c复制代码#include<stdio.h>#include<stdlib.h>// 定义链表节点结构体typedef struct Node {int value;struct Node* next;} Node;// 插入节点到链表尾部Node* insertNode(Node* head, int value) {Node* newNode = (Node*)malloc(sizeof(Node));newNode->value = value;newNode->next = NULL;if (head == NULL) {head = newNode;} else {Node* current = head;while (current->next != NULL) {current = current->next;}current->next = newNode;}return head;}// 将无序整数数组按照升序排列,并将结果存储在链表中Node* sortAndBuildList(int arr[], int n) {Node* head = NULL; // 头节点指针,初始为空for (int i = 0; i < n; i++) { // 将数组元素插入链表尾部head = insertNode(head, arr[i]);}// 对链表进行排序(可以使用快速排序、归并排序等算法)// 这里简单起见,只使用了冒泡排序算法进行排序,实际应用中应使用更高效的排序算法。
python链表算法题
python链表算法题给定一个链表的头节点,删除链表中所有重复出现的元素,使每个元素只出现一次。
示例:输入: 1->1->2->3->3输出: 1->2->3下面是一个可能的解决方案:```pythonclass ListNode:def __init__(self, val=0, next=None):self.val = valself.next = nextdef deleteDuplicates(head):if not head or not head.next:return headdummy = ListNode(0)dummy.next = headprev, curr = dummy, headwhile curr:while curr.next and curr.val == curr.next.val:curr = curr.nextif curr != prev.next:prev.next = curr.nextelse:prev = prev.nextcurr = curr.nextreturn dummy.next该算法使用双指针方法,其中prev指针指向当前节点的前一个节点,curr指针指向当前节点。
我们遍历链表,如果当前节点的值与下一个节点的值相等,则继续向后遍历。
如果当前节点的值与下一个节点的值不相等,则将prev指针的next指针指向当前节点的下一个节点,以便删除重复节点。
如果当前节点和前一个节点的下一个节点是同一个节点,则不进行删除操作。
最后返回dummy.next即可得到删除重复节点后的链表。
习题3(链表)
习题3(链表)一、选择题(1)链接存储的存储结构所占存储空间( A )。
A)分两部分,一部分存放结点值,另一部分存放表示结点间关系的指针B)只有一部分,存放结点值C)只有一部分,存储表示结点间关系的指针D)分两部分,一部分存放结点值,另一部分存放结点所占单元数(2)线性表若采用链式存储结构时,要求内存中可用存储单元的地址( D )。
A)必须是连续的B)部分地址必须是连续的C)一定是不连续的D)连续或不连续都可以(3)线性表L在( 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 )。
数据结构——链表PTA习题
数据结构——链表PTA习题文章目录•••oo▪▪▪oo▪▪▪oo▪▪▪o单选题题号题目答案1 结点的单链表中,实现下列哪个操作,其算法的时间复杂度是O(N)?遍历链表和求链表的第i个结点2 对于一个具有N个结点的单链表,在给定值为x的结点后插入一个新结点的时间复杂度为O(N)3 线性表若采用链式存储结构时,要求内存中可用存储单元的地址连续或不连续都可以题号题目答案4 某线性表中最常用的操作是在最后一个元素之后插入一个元素和删除第一个元素,则采用什么存储方式最节省运算时间?仅有尾指针的单循环链表5 若某表最常用的操作是在最后一个结点之后插入一个结点或删除最后一个结点。
则采用哪种存储方式最节省运算时间?带头结点的双循环链表6 线性表L在什么情况下适用于使用链式结构实现?需不断对L进行删除插入7 将线性表La和Lb头尾连接,要求时间复杂度为O(1),且占用辅助空间尽量小。
应该使用哪种结构?带尾指针的单循环链表8 链表不具有的特点是:方便随机访问任一元素9 在单链表中,若p所指的结点不是最后结点,在p之后插入s所指结点,则执行s->next=p->next;p->next=s;10 将两个结点数都为N且都从小到大有序的单向链表合并成一个从小到大有序的单向链表,那么可能的最少比较次数是:N函数题6-1 链式表的按序号查找本题要求实现一个函数,找到并返回链式表的第K个元素。
L是给定单链表,函数FindKth要返回链式表的第K个元素。
如果该元素不存在,则返回ERROR。
输入样例:1 3 4 52 -163 6 1 54 2输出样例:4 NA 1 25 3代码#include <stdio.h>#include <stdlib.h>#define ERROR -1typedef int ElementType; typedef struct LNode *PtrToLNode; struct LNode {ElementType Data; PtrToLNode Next;};typedef PtrT oLNode List;List Read(); /* 细节在此不表 */ ElementType FindKth(List L, int K);int main(){int N, K;ElementType X;List L = Read();scanf("%d", &N);while (N--) {scanf("%d", &K);X = FindKth(L, K);if (X != ERROR)printf("%d ", X);elseprintf("NA ");}return 0;}/* 你的代码将被嵌在这里 */ElementType FindKth(List L, int K) {// K是索引值+1 设置count计数时候也要从1 开始int count = 1;PtrToLNode p = L;while (L != NULL && count < K){p = p->Next;count++;}if (p&&count == K)return p->Data;elsereturn ERROR;}6-3 建立学生信息链表 (20分)本题要求实现一个将输入的学生成绩组织成单向链表的简单函数。
实现单链表的就地逆置算法
实现单链表的就地逆置算法题目:有一个线性表(a1,a2,a3,....,an),采用带头节点的单链表L存储,设计一个算法将其就地逆置。
所谓“就地”指辅助空间应该为O(1)。
方法一:采用头插法先将L的头节点head的Next域置为NULL变成一个空链表,然后用p结点采用头插法插入到L中。
[java] view plaincopy1.static Node headInsert(Node head){2.if(head == null || head.next == null){3.System.out.println("逆置的单链表至少有2个结点");4.return null;5.}6.else{7.Node p = head.next;8.head.next = null;9.Node q = null;10.while(p != null){11.q = p;12.p = p.next;13.q.next = head;14.head = q;15.}16.return q;17.}18.}方法二:先将首节点的next置为NULL,用p,q指向单链表中相邻的两节点,将r指向q的下一个结点,然后同步后移。
当q=NULL时,表示指向原单链表的尾结点,将L的next域指向p即可。
[java] view plaincopy1.static Node invert(Node head){2.Node p,q,r;3.if(head == null || head.next == null){4.System.out.println("逆置的单链表至少有2个结点");5.return null;6.}7.else{8.p = head;9.q = p.next;10.while(q != null){11.r = q.next;12.q.next = p;13.p = q;14.q = r;15.}16.head.next = null;17.head = p;18.return head;19.}20.}[java] view plaincopy。
c++关于链表的编程题
链表编程题:逆转单链表
一、题目描述:
给定一个链表的头节点head,逆转链表并返回新的头节点。
二、输入描述:
链表节点的定义如下:
输入为一个链表的头节点,每个节点包含一个整数值。
三、输出描述:
输出逆转后的链表的头节点。
四、示例:
输入:head = [1,2,3,4,5] 输出:[5,4,3,2,1]
五、解题思路:
本题可以使用迭代或递归的方式解决。
由于链表的节点是动态分配的,因此迭代方式更加高效。
迭代方式的基本思路是使用两个指针,一个指针用于遍历链表,另一个指针用于记录下一个要访问的节点。
具体步骤如下:
1.定义两个指针pre 和cur,初始时都指向头节点head。
2.遍历链表,每次将cur 的值赋给pre,将cur 的next 指针指向pre 的
下一个节点。
3.重复步骤2,直到cur 为空。
此时pre 的值即为逆转后的链表的头节点。
六、代码实现:。
第三章单链表题目和答案
第2章自测卷答案一、填空1.顺序表中逻辑上相邻的元素的物理位置彼此相邻。
单链表中逻辑上相邻的元素的物理位置不相邻。
2.在单链表中,除首元结点外,任一结点的存储位置由其直接前驱结点值域指示。
3.在n个结点的单链表中要删除结点*p,需找到它的地址。
二、判断正误〔在正确的说法后面打勾,反之打叉〕1. 链表的每一个结点中都恰好包括一个指针。
X2. 链表的物理存储构造具有同链表一样的顺序。
X3. 链表的删除算法很简单,因为当删除链中某个结点后,计算机会自动地将后续的各个单元向前移动。
X4. 线性表的每一个结点只能是一个简单类型,而链表的每一个结点可以是一个复杂类型。
Y5. 顺序表构造适宜于进展顺序存取,而链表适宜于进展随机存取。
Y6. 顺序存储方式的长处是存储密度大,且插入、删除运算效率高。
X7. 线性表在物理存储空间中也必然是持续的。
X8. 线性表在顺序存储时,逻辑上相邻的元素未必在存储的物理位置顺序上相邻。
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中的结点值〔B〕需不断对L进展删除插入〔C〕L中含有大量的结点〔D〕L中结点构造复杂〔C〕5.单链表的存储密度〔A〕大于1;〔B〕等于1;〔C〕小于1;〔D〕不能肯定〔A〕六、在单链表的一个结点中有个指针。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
1链表基本操作typedef struct myLink{int data;struct myLink *next;//创建链表包含头节点int creatLink(Link **phead){int res = 0;int num;Link *ptm = (Link *)malloc(sizeof(Link));ptm->data = 0;*phead = ptm;printf("请输入数据,以0结束!!!\n");scanf("%d", &num);while (num != 0){Link *pNew = (Link *)malloc(sizeof(Link));if (pNew == NULL){res = -1;printf("pNew==NULL 创建链表失败error:%d\n",res);}pNew->data = num;ptm->next = pNew;ptm = pNew;printf("请输入数据,以0结束!!!\n");scanf("%d", &num);}ptm->next = NULL;return res;}//打印链表int printLink(Link *pHead){int res = 0;Link *p = pHead->next;if (p == NULL){res = -1;printf("printfLink() err:%d 链表为空打印失败\n",res);return res;}while (p != NULL){printf("data=%d\n",p->data);p = p->next;}return res;}//插入链表在data=x的前面插入data=y;int insertLink(Link *pHead, int x, int y){int res = 0;if (pHead == NULL){res = -1;printf("pHead==NULL insertLink() err:%d\n",res);return res;}Link *pNew = (Link *)malloc(sizeof(Link));pNew->data = y;Link *pPre = pHead;Link *pCurr = pHead->next;int flag = 0;while (pCurr != NULL){if (pCurr->data == x){flag = 1;break;}pPre = pPre->next;pCurr = pCurr->next;}if (flag == 0){res = -2;printf("原链表中没有%d\n",x);return res;}pNew->next = pCurr;pPre->next = pNew;return res;}//删除链表中节点删除data=x的节点int deleLink(Link *pHead, int x){int res = 0;if (pHead == NULL){res = -1;printf("pHead==NULL deleLink() error:%d\n",res);return res;}Link *pPre = pHead;Link *pCurr = pHead->next;int flag = 0;while (pCurr != NULL){if (pCurr->data == x){flag = 1;break;}pPre = pPre->next;pCurr = pCurr->next;}if (flag == 0){res = -2;printf("原链表中没有%d\n", x);return res;}pPre->next = pCurr->next;return res;}//反转链表int revertLink(Link *pHead){int res = 0;if (pHead == NULL||pHead->next==NULL||pHead->next->next==NULL) {res = -1;printf("pHead==NULL revertLink() error:%d\n",res);return res;}Link *pPre = pHead->next;Link *pCurr = pHead->next->next;Link *q = NULL;while (pCurr != NULL){q = pCurr->next;pCurr->next = pPre;pPre = pCurr;pCurr = q;}pHead->next->next = NULL;pHead->next = pPre;return res;}//链表排序//再创建一个空链表从原链表中找到最大值的那个节点然后往空链表里添加int sortLink(Link *pHead,Link **pHead1){int res = 0;Link *pNewHead = (Link *)malloc(sizeof(Link));pNewHead->data = 0;Link *pNewTail = pNewHead;if (pHead == NULL){res = -1;printf("pHead==NULL sortLink() erro:%d\n", res);return res;}//先从原链表里找出最大值的那个节点start:{Link *pMax = pHead->next;Link *pPre = pHead;Link *pCurr = pMax->next;while (pCurr != NULL){if (pCurr->data > pMax->data){pPre = pMax;pMax = pCurr;}pCurr = pCurr->next;}pPre->next = pMax->next;// 让最大的那个节点脱离原链表if (pNewHead->next == NULL){pNewHead->next = pMax;pNewTail = pMax;pMax->next = NULL;}else{pNewTail->next = pMax;pNewTail = pMax;pMax->next = NULL;}if (pHead->next == NULL) //所有的节点都脱离了原链表{goto sortEnd;}goto start;}sortEnd:*pHead1 = pNewHead;return res;}int destoryLink(Link **pHead){int res = 0;if (pHead == NULL){res = -1;printf("pHead==NULL 链表为空释放内存失败erro:%d\n",res);return res;}Link *pt = *pHead;while (pt != NULL){Link *tmp = pt->next;free(pt);pt =tmp;}*pHead = NULL;return res;}//测试案例void main(){Link *pHead = NULL;int res;res = creatLink(&pHead);if (res != 0){printf("function creatLink() err:%d\n",res);goto End;}res = printLink(pHead);if (res != 0){printf("function printLink() err:%d\n", res);goto End;}printf("**************** 在3的前面插入4 **************************\n");res = insertLink(pHead,3,4);if (res != 0){printf("function insetrLink() err:%d\n", res);goto End;}res = printLink(pHead);if (res != 0){printf("function printLink() err:%d\n", res);goto End;}printf("**************** 删除data=4的节点**************************\n");res = deleLink(pHead,4);if (res != 0){printf("function deleLink() err:%d\n", res);goto End;}res = printLink(pHead);if (res != 0){printf("function printLink() err:%d\n", res);goto End;}printf("**************** 逆转链表**************************\n");res = revertLink(pHead);if (res != 0){printf("function revertLink() err:%d\n", res);goto End;}res = printLink(pHead);if (res != 0){printf("function printLink() err:%d\n", res);goto End;}printf("**************** 从大到小排序链表**************************\n");Link *pHead1 = NULL;res = sortLink(pHead,&pHead1);if (res != 0){printf("function sortLink() err:%d\n", res);goto End;}res = printLink(pHead1);if (res != 0){printf("function printLink() err:%d\n", res);goto End;}End:if (pHead != NULL){res = destoryLink(&pHead);if (res != 0){printf("function destoryLink() is error:%d\n",res);return;}}system("pause");}2、单链表的建立,把‘a’--‘z’26个字母插入到链表中,并且倒叙,还要打印#include <stdio.h>#include <stdlib.h>typedef struct val{char data;struct val *next;}node,*p;void main(void){node *p = NULL;node *q = NULL;node *head = (node *)malloc(sizeof(node));head->data = ' ';head->next = NULL;node *first = (node *)malloc(sizeof(node));first->data = 'a';first->next = NULL;head->next = first;p = first;int longth = 'z' - 'b';int i = 0;while (i <= longth){node *temp = (node *)malloc(sizeof(node));temp->data = 'b'+i;temp->data = NULL;//开始逆转q = temp;head->next = temp;temp->next = p;p = q;i++;}//打印链表node *tmp = head->next;while (tmp!= NULL){printf("data:%c ",tmp->data);tmp = tmp->next;}}3约瑟夫问题循环链表.h文件#ifndef _CIRCLELIST_H_#define _CIRCLELIST_H_typedef void CircleList;/*typedef struct _tag_CircleListNode CircleListNode;struct _tag_CircleListNode{CircleListNode* next;};*/typedef struct _tag_CircleListNode{struct _tag_CircleListNode * next;}CircleListNode;CircleList* CircleList_Create();void CircleList_Destroy(CircleList* list);void CircleList_Clear(CircleList* list);int CircleList_Length(CircleList* list);int CircleList_Insert(CircleList* list, CircleListNode* node, int pos); CircleListNode* CircleList_Get(CircleList* list, int pos);CircleListNode* CircleList_Delete(CircleList* list, int pos);//addCircleListNode* CircleList_DeleteNode(CircleList* list, CircleListNode* node); CircleListNode* CircleList_Reset(CircleList* list);CircleListNode* CircleList_Current(CircleList* list);CircleListNode* CircleList_Next(CircleList* list);#endifC. 文件#include <stdio.h>#include <malloc.h>#include "circleList.h"typedef struct _tag_CircleList{CircleListNode header;CircleListNode* slider;int length;} TCircleList;CircleList* CircleList_Create() // O(1){TCircleList* ret = (TCircleList*)malloc(sizeof(TCircleList));if (ret == NULL){return NULL;}ret->length = 0;ret->header.next = NULL;ret->slider = NULL;return ret;}void CircleList_Destroy(CircleList* list) // O(1){if (list == NULL){return ;}free(list);}void CircleList_Clear(CircleList* list) // O(1){TCircleList* sList = (TCircleList*)list;if (sList == NULL){return ;}sList->length = 0;sList->header.next = NULL;sList->slider = NULL;}int CircleList_Length(CircleList* list) // O(1){TCircleList* sList = (TCircleList*)list;int ret = -1;if (list == NULL){return ret;}ret = sList->length;return ret;}int CircleList_Insert(CircleList* list, CircleListNode* node, int pos) // O(n) {int ret = 0, i=0;TCircleList* sList = (TCircleList*)list;if (list == NULL || node== NULL || pos<0){return -1;}//if( ret ){CircleListNode* current = (CircleListNode*)sList;for(i=0; (i<pos) && (current->next != NULL); i++){current = current->next;}//current->next 0号节点的地址node->next = current->next; //1current->next = node; //2//若第一次插入节点if( sList->length == 0 ){sList->slider = node;}sList->length++;//若头插法if( current == (CircleListNode*)sList ){//获取最后一个元素CircleListNode* last = CircleList_Get(sList, sList->length - 1);last->next = current->next; //3}}return ret;}CircleListNode* CircleList_Get(CircleList* list, int pos) // O(n){TCircleList* sList = (TCircleList*)list;CircleListNode* ret = NULL;int i = 0;if (list==NULL || pos<0){return NULL;}//if( (sList != NULL) && (pos >= 0) && (sList->length > 0) ){CircleListNode* current = (CircleListNode*)sList;for(i=0; i<pos; i++){current = current->next;}ret = current->next;}return ret;}CircleListNode* CircleList_Delete(CircleList* list, int pos) // O(n){TCircleList* sList = (TCircleList*)list;CircleListNode* ret = NULL;int i = 0;if( (sList != NULL) && (pos >= 0) && (sList->length > 0) ){CircleListNode* current = (CircleListNode*)sList;CircleListNode* last = NULL;for(i=0; i<pos; i++){current = current->next;}//若删除第一个元素if( current == (CircleListNode*)sList ){last = (CircleListNode*)CircleList_Get(sList, sList->length - 1);}//求要删除的元素ret = current->next;current->next = ret->next;sList->length--;//判断链表是否为空if( last != NULL ){sList->header.next = ret->next;last->next = ret->next;}//若删除的元素为游标所指的元素if( sList->slider == ret ){sList->slider = ret->next;}//若删除元素后,链表长度为0if( sList->length == 0 ){sList->header.next = NULL;sList->slider = NULL;}}return ret;}CircleListNode* CircleList_DeleteNode(CircleList* list, CircleListNode* node) // O(n) {TCircleList* sList = (TCircleList*)list;CircleListNode* ret = NULL;int i = 0;if( sList != NULL ){CircleListNode* current = (CircleListNode*)sList;//查找node在循环链表中的位置ifor(i=0; i<sList->length; i++){if( current->next == node ){ret = current->next;break;}current = current->next;}//如果ret找到,根据i去删除if( ret != NULL ){CircleList_Delete(sList, i);}}return ret;}CircleListNode* CircleList_Reset(CircleList* list) // O(1) {TCircleList* sList = (TCircleList*)list;CircleListNode* ret = NULL;if( sList != NULL ){sList->slider = sList->header.next;ret = sList->slider;}return ret;}CircleListNode* CircleList_Current(CircleList* list) // O(1) {TCircleList* sList = (TCircleList*)list;CircleListNode* ret = NULL;if( sList != NULL ){ret = sList->slider;}return ret;}CircleListNode* CircleList_Next(CircleList* list) // O(1) {TCircleList* sList = (TCircleList*)list;CircleListNode* ret = NULL;if( (sList != NULL) && (sList->slider != NULL) ){ret = sList->slider;sList->slider = ret->next;}return ret;}Main.c 文件#include <stdio.h>#include <stdlib.h>#include "circlelist.h"typedef struct Value{CircleListNode node;int v;}Va;void main(){CircleList *circleList = NULL;circleList = CircleList_Create();Va v1, v2, v3, v4, v5, v6, v7, v8;v1.v = 1; v2.v = 2; v3.v = 3; v4.v = 4;v5.v = 5; v6.v = 6; v7.v = 7; v8.v = 8;int res;res = CircleList_Insert(circleList, (CircleListNode *)&v1, CircleList_Length(circleList));res = CircleList_Insert(circleList, (CircleListNode *)&v2, CircleList_Length(circleList));res = CircleList_Insert(circleList, (CircleListNode *)&v3, CircleList_Length(circleList));res = CircleList_Insert(circleList, (CircleListNode *)&v4, CircleList_Length(circleList));res = CircleList_Insert(circleList, (CircleListNode *)&v5, CircleList_Length(circleList));res = CircleList_Insert(circleList, (CircleListNode *)&v6, CircleList_Length(circleList));res = CircleList_Insert(circleList, (CircleListNode *)&v7, CircleList_Length(circleList));res = CircleList_Insert(circleList, (CircleListNode *)&v8, CircleList_Length(circleList));int len = CircleList_Length(circleList);for (int i = 0; i < len; i++){Va *tmp = (Va *)CircleList_Get(circleList, i);if (tmp != NULL){printf("tmp v:%d\n",tmp->v);}}CircleList_Reset(circleList);printf("\n\n");Va *tmp = NULL;while (CircleList_Length(circleList) > 0){for (int i = 1; i < 3; i++){CircleList_Next(circleList); // 让游标后移两步}tmp = (Va *)CircleList_Current(circleList); //获取游标所指的元素printf("tmp v:%d\n", tmp->v);CircleList_DeleteNode(circleList, (CircleListNode *)tmp); //删除该节点并让游标后移}//CircleList_Clear(circleList);CircleList_Destroy(circleList);system("pause");}4有一个数组a[1000]存放0-1000;要求每个二个数删除一个,到末尾是循环至开头继续进行,求最后一个被删除的数的原始下标位置#include<iostream>using namespace std;struct node{int data;node*next;};int main(){node*head=new node;head->data=0;head->next=NULL;node*p=head;//创建链表for(int i=1;i<1000;i++){node*tmp=new node;tmp->data=i;tmp->next=NULL;head->next=tmp;head=head->next;}//把链表的尾和头连上创建循环链表head->next=p;while(p!=p->next){p->next->next=p->next->next->next->next;p=p->next->next;}cout<<p->data<<endl;return0;}5 已知链两个链表head1和head2各自有序,请把他们合并一个链表依然有序,这次要求用递归方法进行typedef struct Node{int data;struct Node*next;}Node;Node*MergeRecursive(Node*head1,Node*head2){if(head1==NULL)return head2;if(head2==NULL)return head1;Node*head=NULL;if(head1->data<head2->data){head=head1;head->next=MergeRecursive(head1->next,head2);}else{head=head2;head->next=MergeRecursive(head1,head2->next);}return head;}6 如何判断一个单链表是有环的?用两个指针,一个每次递增一步,一个每次递增两步,如果有环的话两者必定重合struct node{int data;node*next;};//返回true为有环bool check(const node*head){if(head==NULL)return false;node*low=head;node*fast=head->next;while(fast!=NULL&&fast->next!=NULL){low=low->next;fast=fast->next->next;if(low==fast)return true;}return false;}7 线性表a b 为两个有序升序的线性表,编写一程序,使两个有序线性表合并成一个有序升序线性表Link *union(Linklist *p, Linklist *q){linklist *R,*pa,*qa,*ra;pa=p;qa=q;R=ra=p;while(pa->next!=NULL&&qa->next!=NULL){if(pa->data>qa->data){ra->next=qa;qa=qa->next;}else{ra->next=pa;pa=pa->next;}}if(pa->next!=NULL){ra->next=pa;}if(qa->next!=NULL){ra->next=qa;}return R; }。