链表试题算法汇总
单链表、双链表、循环链表和静态链表的习题

单链表、双链表、循环链表和静态链表的习题一、单项选择题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、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 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; }。