数据结构_双向链表的实现和测试(C)
智慧树知到《数据结构》章节测试答案
第1章单元测试1、算法的时间复杂度取决于___。
答案:A和B2、数据在计算机内存中的表示是指()答案:数据的存储结构3、算法指的是()答案:求解特定问题的指令有限序列4、在数据结构中,与所使用的计算机无关的数据结构是()答案:逻辑7、某线性表采用顺序存储结构,每个元素占4个存储单元,首地址为100,则第12个元素的存储地址为( )。
答案:1448、算法能正确地实现预定功能的特性称为算法的()。
答案:正确性第2章单元测试1、链表不具备的特点是()。
答案:可随机访问任意一个结点3、线性表的顺序存储表示优于链式存储表示。
答案:错4、顺序存储结构的缺点是不便于修改,插入和删除需要移动很多结点。
答案:对5、在设头、尾指针的单链表中,与长度n有关的操作是( )。
答案:删除最后一个结点6、设指针q指向单链表中结点A,指针p指向单链表中结点A的后继结点B,指针s指向被插入的结点X,则在结点A和结点B间插入结点X的操作序列为( )。
答案:q->next=s; s->next=p;7、对于只在表的首、尾两端进行插入操作的线性表,宜采用的存储结构为( )。
答案:用尾指针表示的循环单链表8、在一个单链表中,若p所指节点不是最后节点,在p之后插入s所指节点,则执行( )。
答案:s->link=p->link;p->link=s;9、在双向链表存储结构中,删除p所指的结点时须修改指针____。
答案:p->next->prior=p->prior; p->prior->next=p->next;10、若事先不知道线性表的长度,则处理线性表时较好的存储结构是( )。
答案:单链表11、向一个有127个元素的顺序表中插入一个新元素并保存,原来顺序不变,平均要移动( )个元素。
答案:63.512、某线性表采用顺序存储结构,每个元素占4个存储单元,首地址为100,则第12个元素的存储地址为( )。
数据结构C语言版 实验报告
数据结构C语言版实验报告一、实验目的本次实验旨在通过使用 C 语言实现常见的数据结构,加深对数据结构基本概念、原理和操作的理解,提高编程能力和解决实际问题的能力。
二、实验环境操作系统:Windows 10编程环境:Visual Studio 2019编程语言:C 语言三、实验内容1、线性表顺序表的实现与操作链表的实现与操作2、栈和队列栈的实现与应用(表达式求值)队列的实现与应用(模拟排队)3、树和二叉树二叉树的遍历(前序、中序、后序)二叉搜索树的实现与操作4、图图的存储结构(邻接矩阵、邻接表)图的遍历(深度优先搜索、广度优先搜索)四、实验步骤及结果1、线性表顺序表的实现与操作定义顺序表的数据结构,包括数组和表的长度。
实现顺序表的初始化、插入、删除、查找等操作。
测试顺序表的各种操作,输出操作结果。
```cinclude <stdioh>include <stdlibh>define MAX_SIZE 100typedef struct {int dataMAX_SIZE;int length;} SeqList;//初始化顺序表void initList(SeqList L) {L>length = 0;}//插入元素到顺序表int insertList(SeqList L, int pos, int element) {if (L>length >= MAX_SIZE || pos < 0 || pos > L>length) {return 0;}for (int i = L>length 1; i >= pos; i) {L>datai + 1 = L>datai;}L>datapos = element;L>length++;return 1;}//删除顺序表中的元素int deleteList(SeqList L, int pos) {if (pos < 0 || pos >= L>length) {return 0;}for (int i = pos; i < L>length 1; i++){L>datai = L>datai + 1;}L>length;return 1;}//查找顺序表中的元素int searchList(SeqList L, int element) {for (int i = 0; i < Llength; i++){if (Ldatai == element) {return i;}}return -1;}int main(){SeqList L;initList(&L);insertList(&L, 0, 10);insertList(&L, 1, 20);insertList(&L, 2, 30);printf("顺序表元素: ");for (int i = 0; i < Llength; i++){printf("%d ", Ldatai);}printf("\n");int pos = searchList(L, 20);if (pos!=-1) {printf("元素 20 在顺序表中的位置: %d\n", pos);} else {printf("顺序表中未找到元素 20\n");}deleteList(&L, 1);printf("删除元素后的顺序表元素: ");for (int i = 0; i < Llength; i++){printf("%d ", Ldatai);}printf("\n");return 0;}```实验结果:成功实现顺序表的初始化、插入、删除、查找等操作,输出结果符合预期。
数据结构练习试卷1(题后含答案及解析)
数据结构练习试卷1(题后含答案及解析)题型有:1. 选择题选择题(每小题1分,共75分)下列各题A、B、C、D四个选项中,只有一个选项是正确的,请将此选项涂写在答题卡相应位置上,答在试卷上不得分。
1.数据结构主要研究数据的______。
A.逻辑结构B.存储结构C.逻辑结构和存储结构D.逻辑结构和存储结构及其运算的实现正确答案:D解析:数据结构是相互之间存在一种或多种特定关系的数据元素的集合。
数据结构一般包括三方面的内容:①数据之间的逻辑关系。
从逻辑关系上描述数据,与数据的存储无关。
②数据的存储结构。
存储结构分为顺序结构和链式结构,是逻辑结构在计算机存储器中的表示,它包括数据元素的表示和关系的表示。
③数据的运算。
也就是在数据上所施加的一系列操作。
只考虑操作的功能是怎样的,暂不考虑如何实现。
综上所述,本题的正确答案为选项D。
知识模块:数据结构2.在数据结构中,结点(数据元素)及结点间的相互关系组成数据的逻辑结构。
按逻辑结构的不同,数据结构通常可分为______两类。
A.线性结构和非线性结构B.紧凑结构和稀疏结构C.动态结构和静态结构D.内部结构和外部结构正确答案:A解析:在数据结构中,结点(数据元素)及结点间的相互关系组成数据的逻辑结构。
按逻辑结构的不同,数据结构通常可分为线性结构和非线性结构两类。
本题正确答案为选项A。
知识模块:数据结构3.下面叙述不正确的是______。
A.算法的执行效率与数据的存储结构有关B.算法的空间复杂度是指执行这个算法所需要的内存空间C.算法的有穷性是指算法必须能在执行有限个步骤之后终止D.算法的时间复杂度是指执行这个算法所需要的时间正确答案:D解析:算法的时间复杂度是指执行算法所需要的计算工作量,故D选项不正确。
知识模块:数据结构4.数据的存储结构是指______。
A.数据所占的存储空间量B.数据的逻辑结构在计算机中的表示C.数据在计算机中的顺序存储方式D.存储在外存中的数据正确答案:B解析:数据的存储结构是数据元素在计算机存储器内的表示。
国家二级C语言机试数据结构与算法-试卷2-1_真题(含答案与解析)-交互
国家二级C语言机试(数据结构与算法)-试卷2-1(总分76, 做题时间90分钟)1. 选择题1.对长度为10的线性表进行冒泡排序,最坏情况下需要比较的次数为()。
SSS_SINGLE_SELA 9B 10C 45D 90分值: 2答案:C解析:在最坏情况下,冒泡排序的时间复杂度为n(n-1)/2,为45,答案选C。
2.下列叙述中正确的是()。
SSS_SINGLE_SELA 算法的效率只与问题的规模有关,而与数据的存储结构无关B 算法的时间复杂度是指执行算法所需要的计算工作量C 数据的逻辑结构与存储结构是一一对应的D 算法的时间复杂度与空间复杂度一定相关分值: 2答案:B解析:算法的时间复杂度是指执行算法所需要的计算工作量,与数据的存储结构有关,与算法的空间复杂度没有关系。
数据的逻辑结构与存储位置无关,即与存储结构无关,所以选择B。
3.下列叙述中正确的是()。
SSS_SINGLE_SELA 线性表链式存储结构的存储空间一般要少于顺序存储结构B 线性表链式存储结构与顺序存储结构的存储空间都是连续的C 线性表链式存储结构的存储空间可以是连续的,也可以是不连续的D 以上说法都不对分值: 2答案:C解析:在链式存储结构中,存储数据结构的存储空间可以不连续,各数据结点的存储顺序与数据元素之间的逻辑关系可以不一致,而数据元素之间的逻辑关系是由指针域来确定的,所以选择C。
4.某二叉树共有12个结点,其中叶子结点只有1个。
则该二叉树的深度为(根结点在第1层)()。
SSS_SINGLE_SELA 3B 6D 12分值: 2答案:D解析:根据二叉树的性质,叶子结点比度为2的结点个数多一个,叶子结点只有1个,那么度为2的结点为0个,可以得出共有11个度为1的结点,那么该二叉树每一层上只能有一个结点,共12层,即深度为12。
5.对长度为n的线性表作快速排序,在最坏情况下,比较次数为()。
SSS_SINGLE_SELA nB n-1C n(n-1)D n(n-1)/2分值: 2答案:D解析:在最坏情况下,快速排序需要比较n(n-1)/2次。
数据结构(山东联盟-滨州学院)智慧树知到答案章节测试2023年
第一章测试1.数据在计算机内存中的表示是指()A:数据元素之间的关系B:数据的逻辑结构C:数据的存储结构D:数据结构答案:C2.算法指的是()A:计算机程序B:解决问题的有限运算序列C:解决问题的计算方法D:排序算法答案:B3.在数据结构中,与所使用的计算机无关的数据结构是()A:逻辑结构和存储结构B:物理结构C:逻辑结构D:存储结构答案:C4.算法能正确地实现预定功能的特性称为算法的()。
A:可读性B:正确性C:健壮性D:高效性答案:B5.已知某算法的执行时间为(n+n2)log2(n+2),n为问题规模,则该算法的时间复杂度是()。
A:O((n+n^2)logn)B:O(nlogn)C:O(n^2logn)D:O(n^2)答案:C6.下面算法将一维数组a中的数据逆序存放到原数组中,空间复杂度为()。
for(i=0;i<n;i++) b[i] = a[n-i-1];for(i=0;i<n;i++) a[i] = b[i];A:O(n2)B:O(n)C:O(logn)D:O(1)答案:B第二章测试1.链表不具备的特点是()。
A:不必事先估计存储空间B:所需空间与其长度成正比C:插入和删除不需要移动任何元素D:可随机访问任意一个结点答案:D2.线性表的顺序存储表示优于链式存储表示。
A:对B:错答案:B3.顺序存储结构的缺点是不便于修改,插入和删除需要移动很多结点。
A:错B:对答案:B4.在设头、尾指针的单链表中,与长度n有关的操作是( )。
A:删除最后一个结点B:在p结点之后插入一个结点C:删除第一个结点D:在第一个结点之前插入一个结点答案:A5.设指针q指向单链表中结点A,指针p指向单链表中结点A的后继结点B,指针s指向被插入的结点X,则在结点A和结点B间插入结点X的操作序列为( )。
A:p->next=s->next;s->next=p;B:p->next=s;s->next=q;C:s->next=p->next;p->next=-s;D:q->next=s; s->next=p;答案:D6.对于只在表的首、尾两端进行插入操作的线性表,宜采用的存储结构为( )。
国家开放大学《数据结构(本)》单元测试参考答案
31.顺序存储方式只能用于存储线性结构。(×) 32.顺序存储方式的有点是存储密度大,且插入、删除运算效率高。(×)
单元 3 栈和队列 1.一个顺序栈一旦被声明,其占用空间的大小( )。
A. 已固定 B. 动态变化 C. 可以改变 D. 不能固定 2.链栈和顺序栈相比,有一个比较明显的缺点,即( )。 A. 不会出现栈空的情况 B. 插入操作更加方便 C. 删除操作更加方便 D. 通常不会出现栈满的情况 3.用单链表表示的链式队列的队头在链表的( )位置。 A. 链头 B. 任意位置 C. 链尾 D. 链中 4.在解决计算机主机与打印机之间速度不匹配问题时通常设置一个打印数据缓 冲区,主机将要输出的数据依次写入缓冲区中,而打印机则从缓冲区中取出数据 打印,该缓冲区应该是一个( )结构。 A. 数组 B. 堆栈 C. 队列 D. 线性表 5.循环队列 A[m] 存放其元素,用 front 和 rear 分别表示队头及队尾,则循环队 列满的条件是( )。
12.一个栈的进栈序列是 5,6,7,8,则栈的不可能的出栈序列是( )。(进 出栈操作可以交替进行)
A. 8,7,6,5 B. 7,6,8,5 C. 7,6,5,8 D. 5,8,6,7 13.栈的插入删除操作在( )进行。 A. 栈底 B. 栈顶 C. 指定位置 D. 任意位置 14.栈和队列的相同点是( )。 A. 逻辑结构与线性表相同,都是操作规则受到限制的线性表 B. 逻辑结构与线性表不同 C. 都是后进后出 D. 都是后进先出 15.以下说法正确的是( )。 A. 栈的特点是先进先出,队列的特点是先进后出 B. 栈和队列的特点都是先进后出
14.算法是在数据结构的基础上对特定问题求解步骤的一种描述,也是若干条指 令组成的优先序列(√)。 15.算法可以用不同的语言描述,如果用 C 语言等高级语言来描述,则算法实际 上就是程序了(×)。 16.程序一定是算法(×)。 17.数据的物理结构是指数据在计算机内的实际存储形式(√)。 18.数据结构中评价算法的两个重要指标是时间复杂度和空间复杂度(√)。 19.在顺序存储结构中,有时也存储数据结构中元素之间的关系(×)。
双向链表的算法设计与实现实验报告
数学与计算科学学院实验报告
实验项目名称双向链表的算法设计与实现
所属课程名称__数据结构A
实验类型设计型
实验日期__
班级信计1402
学号201453100214
姓名俞凯烨
成绩
【实验小结】(收获体会)
附录1:源程序
附录2:实验报告填写说明
1.实验项目名称:要求与实验教学大纲一致。
2.实验目的:目的要明确,要抓住重点,符合实验教学大纲要求。
3.实验原理:简要说明本实验项目所涉及的理论知识。
4.实验环境:实验用的软、硬件环境。
5.实验方案(思路、步骤和方法等):这是实验报告极其重要的内容。
概括整个实验过程。
对于验证性实验,要写明依据何种原理、操作方法进行实验,要写明需要经过哪几个步骤来实现其操作。
对于设计性和综合性实验,在上述内容基础上还应该画出流程图、设计思路和设计方法,再配以相应的文字说明。
对于创新性实验,还应注明其创新点、特色。
6.实验过程(实验中涉及的记录、数据、分析):写明具体实验方案的具体实施步骤,包括实验过程中的记录、数据和相应的分析。
7.实验结论(结果):根据实验过程中得到的结果,做出结论。
8.实验小结:本次实验心得体会、思考和建议。
9.指导教师评语及成绩:指导教师依据学生的实际报告内容,给出本次实验报告的评价。
数据结构C语言版期末考试试题(有答案)
“数据结构”期末考试试题一、单选题(每小题2分,共12分)1.在一个单链表HL中,若要向表头插入一个由指针p指向的结点,则执行( B)。
A. HL=ps p一>next=HLB. p一>next=HL;HL=pC. p一>next=Hl;p=HL;D. p一>next=HL一>next;HL一>next=p;2.n个顶点的强连通图中至少含有(B)。
A.n—l条有向边B.n条有向边C.n(n—1)/2条有向边D.n(n一1)条有向边3.从一棵二叉搜索树中查找一个元素时,其时间复杂度大致为( C )。
A.O(1)B.O(n)C.O(1Ogzn)D.O(n2)4.由权值分别为3,8,6,2,5的叶子结点生成一棵哈夫曼树,它的带权路径长度为( D )。
A.24 B.48C. 72 D. 535.当一个作为实际传递的对象占用的存储空间较大并可能需要修改时,应最好把它说明为(B)参数,以节省参数值的传输时间和存储参数的空间。
A.整形B.引用型C.指针型D.常值引用型·6.向一个长度为n的顺序表中插人一个新元素的平均时间复杂度为( A )。
A.O(n) B.O(1)C.O(n2) D.O(10g2n)二、填空题(每空1分,共28分)1.数据的存储结构被分为顺序结构链接结构索引结构散列结构四种。
2.在广义表的存储结构中,单元素结点与表元素结点有一个域对应不同,各自分别为值域和子表指针域。
3.——中缀表达式 3十x*(2.4/5—6)所对应的后缀表达式为————。
4.在一棵高度为h的3叉树中,最多含有—(3h一1)/2—结点。
5.假定一棵二叉树的结点数为18,则它的最小深度为—5—,最大深度为—18—·6.在一棵二叉搜索树中,每个分支结点的左子树上所有结点的值一定—小于—该结点的值,右子树上所有结点的值一定—大于—该结点的值。
7.当向一个小根堆插入一个具有最小值的元素时,该元素需要逐层—向上—调整,直到被调整到—堆顶—位置为止。
数据结构实验二链表
数据结构实验二1、实验目的∙熟练掌握线性表的链式存储结构定义及基本操作∙理解循环链表和双链表的特点和基本运算2、实验内容:建立单链表,完成链表(带表头结点)的基本操作:建立链表、插入、删除、查找、输出、求前驱、求后继、两个有序链表的合并操作。
其他基本操作还有销毁链表、将链表置为空表、求链表的长度、获取某位置结点的内容、搜索结点。
1.问题描述:利用线性表的链式存储结构,设计一组输入数据(假定为一组整数),能够对单链表进行如下操作:∙初始化一个带表头结点的空链表;∙创建一个单链表是从无到有地建立起一个链表,即一个一个地输入各结点数据,并建立起前后相互链接的关系。
又分为逆位序(插在表头)输入n 个元素的值和正位序(插在表尾)输入n 个元素的值;∙插入结点可以根据给定位置进行插入(位置插入),也可以根据结点的值插入到已知的链表中(值插入),且保持结点的数据按原来的递增次序排列,形成有序链表。
∙删除结点可以根据给定位置进行删除(位置删除),也可以把链表中查找结点的值为搜索对象的结点全部删除(值删除);∙输出单链表的内容是将链表中各结点的数据依次显示,直到链表尾结点;∙求前驱结点是根据给定结点的值,在单链表中搜索其当前结点的后继结点值为给定的值,将当前结点返回;∙求后继结点是根据给定结点的值,在单链表中搜索其当前结点的值为给定的值,将后继结点返回;∙两个有序链表的合并是分别将两个单链表的结点依次插入到第3 个单链表中,继续保持结点有序;编写主程序,实现对各不同的算法调用。
其它的操作算法描述略。
2.实现要求:对链表的各项操作一定要编写成为C(C++)语言函数,组合成模块化的形式,还要针对每个算法的实现从时间复杂度和空间复杂度上进行评价。
∙“初始化算法”的操作结果:构造一个空的线性表L,产生头结点,并使L 指向此头结点;∙“建立链表算法”初始条件:空链存在;操作结果:选择逆位序或正位序的方法,建立一个单链表,并且返回完成的结果;∙“链表(位置)插入算法”初始条件:已知单链表L 存在;操作结果:在带头结点的单链线性表L 中第i 个位置之前插入元素e;∙“链表(位置)删除算法”初始条件:已知单链表L 存在;操作结果:在带头结点的单链线性表L 中,删除第i 个元素,并由e 返回其值;∙“输出算法”初始条件:链表L 已存在;操作结果:依次输出链表的各个结点的值;∙“求前驱算法”初始条件: 线性表L 已存在;操作结果: 若cur_e 是L 的数据元素,且不是第一个,则用pre_e 返回它的前驱;∙“求后继算法”初始条件: 线性表L 已存在;操作结果: 若cur_e 是L 的数据元素,且不是最后一个,则用next_e 返回它的后继;∙“两个有序链表的合并算法”初始条件: 线性表单链线性表La 和Lb 的元素按值非递减排列;操作结果:归并La 和Lb 得到新的单链表。
数据结构中的双向链表实现和应用场景
数据结构中的双向链表实现和应用场景双向链表是一种常用的数据结构,它在许多实际应用中都发挥着重要的作用。
本文将介绍双向链表的实现原理以及一些常见的应用场景。
一、双向链表的实现原理双向链表由一系列节点组成,每个节点包含两个指针,一个指向前一个节点,一个指向后一个节点。
相比于单向链表,双向链表可以实现双向遍历,提高了一些操作的效率。
1.1 节点定义双向链表的节点通常由数据域和两个指针域组成,例如:```struct Node {int data; // 节点数据Node* prev; // 前一个节点指针Node* next; // 后一个节点指针};```1.2 插入操作在双向链表中插入一个节点可以分为两种情况:在表头插入和在表尾插入。
在表头插入时,只需修改原来头节点的prev指针为新节点的地址,并将新节点的next指针指向原头节点即可。
在表尾插入时,需要先找到原来的尾节点,然后将尾节点的next指针指向新节点的地址,并将新节点的prev指针指向尾节点的地址。
1.3 删除操作删除操作与插入操作类似,同样分为在表头和表尾删除节点。
在表头删除时,只需将头节点的next指针指向新的头节点,同时将新头节点的prev指针置为空。
在表尾删除时,需要先找到尾节点的前一个节点,然后将该节点的next指针置为空。
1.4 查找操作双向链表支持从前向后和从后向前两种遍历方式。
从前向后遍历时,我们可以利用节点的next指针不断向后遍历得到所有节点。
同样,从后向前遍历时,可以利用节点的prev指针不断向前遍历得到所有节点。
二、双向链表的应用场景双向链表广泛应用于各种软件和系统中,下面列举了一些常见的应用场景。
2.1 浏览器的历史记录在浏览器中,经常需要记录用户浏览过的网页历史记录。
这时可以使用双向链表来实现。
每当用户访问一个新的网页,就在双向链表中插入一个新节点,同时将新节点的next指针指向前一个节点,prev指针指向后一个节点。
数据结构--数组、单链表和双链表介绍以及双向链表
数据结构--数组、单链表和双链表介绍以及双向链表数组:数组有上界和下界,数组的元素在上下界内是连续的。
数组的特点是:数据是连续的;随机访问速度快。
数组中稍微复杂⼀点的是多维数组和动态数组。
对于C语⾔⽽⾔,多维数组本质上也是通过⼀维数组实现的。
⾄于动态数组,是指数组的容量能动态增长的数组;对于C语⾔⽽⾔,若要提供动态数组,需要⼿动实现;⽽对于C++⽽⾔,STL提供了Vector。
单向链表:单向链表(单链表)是链表的⼀种,它由节点组成,每个节点都包含下⼀个节点的指针。
表头为空,表头的后继节点是"节点10"(数据为10的节点),"节点10"的后继节点是"节点20"(数据为10的节点),"节点20"的后继节点是"节点30"(数据为20的节点),"节点30"的后继节点是"节点40"(数据为10的节点),......删除"节点30"删除之前:"节点20" 的后继节点为"节点30",⽽"节点30" 的后继节点为"节点40"。
删除之后:"节点20" 的后继节点为"节点40"。
在"节点10"与"节点20"之间添加"节点15"添加之前:"节点10" 的后继节点为"节点20"。
添加之后:"节点10" 的后继节点为"节点15",⽽"节点15" 的后继节点为"节点20"。
单链表的特点是:节点的链接⽅向是单向的;相对于数组来说,单链表的的随机访问速度较慢,但是单链表删除/添加数据的效率很⾼。
链表(单链表 双向循环)实验报告讲解
数据结构实验报告T1223-3-21余帅实验一实验题目:仅仅做链表部分难度从上到下1.双向链表,带表头,线性表常规操作。
2.循环表,带表头,线性表常规操作。
3.单链表,带表头,线性表常规操作。
实验目的:了解和掌握线性表的逻辑结构和链式存储结构,掌握单链表的基本算法及相关的时间性能分析。
实验要求:常规操作至少有:1.数据输入或建立2.遍历3.插入4.删除必须能多次反复运行实验主要步骤:1、分析、理解给出的示例程序。
2、调试程序,并设计输入数据,测试程序的如下功能:1.数据输入或建立2.遍历3.插入4.删除单链表示意图:headhead head 创建删除双向循环链表示意图:创建程序代码://单链表#include<iostream.h>#include<windows.h>const MAX=5;enum returninfo{success,fail,overflow,underflow,range_error}; int defaultdata[MAX]={11,22,33,44,55};class node{public:int data;node *next;};class linklist{private:node *headp;protected:int count;public:linklist();~linklist();bool empty();void clearlist();returninfo create(void);returninfo insert(int position,const int &item);returninfo remove(int position) ;returninfo traverse(void);};linklist::linklist(){headp = new node;headp->next = NULL;count=0;}linklist::~linklist(){clearlist();delete headp;}bool linklist::empty(){if(headp->next==NULL)return true;elsereturn false;}void linklist::clearlist(){node *searchp=headp->next,*followp=headp;while(searchp->next!=NULL){followp=searchp;searchp=searchp->next;delete followp;}headp->next = NULL;count = 0;}returninfo linklist::create(){node *searchp=headp,*newnodep;for(int i=0;i<MAX;i++){newnodep = new node;newnodep->data = defaultdata[i];newnodep->next = NULL;searchp->next = newnodep;searchp = searchp->next;count++;}searchp->next = NULL;traverse();return success;}returninfo linklist::insert(int position,const int &item) //插入一个结点{if(position<=0 || position>=count)return range_error;node *newnodep=new node,*searchp=headp->next,*followp=headp;for(int i=1; i<position && searchp!=NULL;i++){followp=searchp;searchp=searchp->next;}newnodep->data=item; //给数据赋值newnodep->next=followp->next; //注意此处的次序相关性followp->next=newnodep;count++; //计数器加一return success;}returninfo linklist::remove(int position) //删除一个结点{if(empty())return underflow;if(position<=0||position>=count+1)return range_error;node *searchp=headp->next,*followp=headp; //这里两个指针的初始值设计一前一后for(int i=1; i<position && searchp!=NULL;i++){followp=searchp;searchp=searchp->next;}followp->next=searchp->next; //删除结点的实际语句delete searchp; //释放该结点count--; //计数器减一return success;}returninfo linklist::traverse(void){node *searchp;if(empty())return underflow;searchp = headp->next;cout<<"连表中的数据为:"<<endl;while(searchp!=NULL){cout<<searchp->data<<" ";searchp = searchp->next;}cout<<endl;return success;}class interfacebase{public:linklist listface; //定义一个对象Cskillstudyonfacevoid clearscreen(void);void showmenu(void);void processmenu(void);};void interfacebase::clearscreen(void){system("cls");}void interfacebase::showmenu(void){cout<<"================================"<<endl;cout<<" 功能菜单 "<<endl;cout<<" 1.创建链表 "<<endl;cout<<" 2.增加结点 "<<endl;cout<<" 3.删除结点 "<<endl;cout<<" 4.遍历链表 "<<endl;cout<<" 0.结束程序 "<<endl;cout<<"======================================"<<endl;cout<<"请输入您的选择:";}void interfacebase::processmenu(void){int returnvalue,item,position;char menuchoice;cin >>menuchoice;switch(menuchoice) //根据用户的选择进行相应的操作{case '1':returnvalue=listface.create();if(returnvalue==success)cout<<"链表创建已完成"<<endl;break;case '2':cout<<"请输入插入位置:"<<endl;cin>>position;cout<<"请输入插入数据:"<<endl;cin>>item;returnvalue = listface.insert(position,item);if(returnvalue==range_error)cout<<"数据个数超出范围"<<endl;elsecout<<"操作成功!!!"<<endl;break;case '3':cout<<"输入你要删除的位置:"<<endl;cin>>position;returnvalue = listface.remove(position);if(returnvalue==underflow)cout<<"链表已空"<<endl;else if(returnvalue==range_error)cout<<"删除的数据位置超区范围"<<endl;elsecout<<"操作成功!!!"<<endl;break;case '4':listface.traverse();break;case '0':cout<<endl<<endl<<"您已经成功退出本系统,欢迎再次使用!!!"<<endl;system("pause");exit(1);default:cout<<"对不起,您输入的功能编号有错!请重新输入!!!"<<endl;break;}}void main(){interfacebase interfacenow;linklist listnow;system("color f0");interfacenow.clearscreen();while(1){interfacenow.showmenu();interfacenow.processmenu();system("pause");interfacenow.clearscreen();}}/* 功能:用双向循环链表存储数据1.创建链表2.增加结点3.删除结点4.遍历链表制作人:余帅内容:239行*/#include<iostream.h>#include<windows.h>const MAX=5;enum returninfo{success,fail,overflow,underflow,range_error}; int defaultdata[MAX]={11,22,33,44,55};class node{public:int data;node * next; //指向后续节点node * pre; //指向前面的节点};class linklist{private:node *headp;protected:int count;public:linklist();~linklist();bool empty();void clearlist();returninfo create(void);returninfo insert(int position,const int &item);returninfo remove(int position) ;returninfo traverse(void);};linklist::linklist(){headp = new node;headp->next = NULL;headp->pre = NULL;count=0;}linklist::~linklist(){clearlist();delete headp;}bool linklist::empty(){if(headp->next==NULL)return true;elsereturn false;}void linklist::clearlist(){node *searchp=headp->next,*followp=headp;while(searchp->next!=NULL){followp=searchp;searchp=searchp->next;delete followp;}headp->next = NULL;headp->pre = NULL;count = 0;}returninfo linklist::create(){node *searchp=headp,*newnodep;for(int i=0;i<MAX;i++){newnodep = new node;newnodep->data = defaultdata[i];newnodep->next = NULL;searchp->next = newnodep;newnodep->pre = searchp;searchp = searchp->next;count++;}searchp->next = headp;headp->pre = searchp;traverse();return success;}returninfo linklist::insert(int position,const int &item) //插入一个结点{if(position<=0 || position>count+1)return range_error;node *newnodep=new node;node *searchp=headp->next,*followp=headp;for(int i=1; i<position && searchp!=NULL;i++){followp=searchp;searchp=searchp->next;}newnodep->data=item; //给数据赋值newnodep->next = searchp;searchp->pre = newnodep;followp->next = newnodep;newnodep->pre = followp;count++; //计数器加一return success;}returninfo linklist::remove(int position) //删除一个结点{if(empty())return underflow;if(position<=0||position>=count+1)return range_error;node *searchp=headp->next,*followp=headp; //这里两个指针的初始值设计一前一后for(int i=1; i<position && searchp!=NULL;i++){followp=searchp;searchp=searchp->next;}followp->next=searchp->next; //删除结点的实际语句searchp->next->pre = followp;delete searchp; //释放该结点count--; //计数器减一return success;}returninfo linklist::traverse(void){node *searchp1,*searchp2;if(empty())return underflow;searchp1 = headp;searchp2 = headp;cout<<"连表中的数据为:"<<endl;cout<<"从左至右读取:";while (searchp1->next!=headp ) {searchp1 = searchp1 ->next;cout << searchp1->data<<" ";}cout<<endl;cout<<"从右至左读取:";while (searchp2->pre!=headp ) {searchp2 = searchp2 ->pre;cout << searchp2->data<<" ";}cout<<endl;return success;}class interfacebase{public:linklist listface; //定义一个对象Cskillstudyonface void clearscreen(void);void showmenu(void);void processmenu(void);};void interfacebase::clearscreen(void){system("cls");}void interfacebase::showmenu(void){cout<<"================================"<<endl;cout<<" 功能菜单 "<<endl;cout<<" 1.创建链表 "<<endl;cout<<" 2.增加结点 "<<endl;cout<<" 3.删除结点 "<<endl;cout<<" 4.遍历链表 "<<endl;cout<<" 0.结束程序 "<<endl;cout<<"======================================"<<endl;cout<<"请输入您的选择:";}void interfacebase::processmenu(void){int returnvalue,item,position;char menuchoice;cin >>menuchoice;switch(menuchoice) //根据用户的选择进行相应的操作{case '1':returnvalue=listface.create();if(returnvalue==success)cout<<"链表创建已完成"<<endl;break;case '2':cout<<"请输入插入位置:"<<endl;cin>>position;cout<<"请输入插入数据:"<<endl;cin>>item;returnvalue = listface.insert(position,item);if(returnvalue==range_error)cout<<"数据个数超出范围"<<endl;elsecout<<"操作成功!!!"<<endl;break;case '3':cout<<"输入你要删除的位置:"<<endl;cin>>position;returnvalue = listface.remove(position);if(returnvalue==underflow)cout<<"链表已空"<<endl;else if(returnvalue==range_error)cout<<"删除的数据位置超区范围"<<endl;elsecout<<"操作成功!!!"<<endl;break;case '4':listface.traverse();break;case '0':cout<<endl<<endl<<"您已经成功退出本系统,欢迎再次使用!!!"<<endl;system("pause");exit(1);default:cout<<"对不起,您输入的功能编号有错!请重新输入!!!"<<endl;break;}}void main(){interfacebase interfacenow;linklist listnow;system("color f0");interfacenow.clearscreen();while(1){interfacenow.showmenu();interfacenow.processmenu();system("pause");interfacenow.clearscreen();}}运行结果:1.创建链表:2.增加结点3.删除结点心得体会:本次实验使我们对链表的实质了解更加明确了,对链表的一些基本操作也更加熟练了。
数据结构c语言版(题目)
分类:编程思想和算法2012-09-15 22:24 1759 人阅读评论(0)收藏举报如果TCPhashlistJuli 采用线性表的顺序存储结构,则可以随机存取表中任一终端,但插入和删除终端时,需要移动大量元素,巧妙地终端离线不进行删除操作。
数组,存储的元素应该是线性表顺序存储结构的数据结构。
线性表题目类型:线性表在顺序结构上各种操作的实现;线性链表的各种操作;两个或多个线性表的各种操作;循环链表和双向链表;稀疏多项式及其运算在线性表的两种存储结构上的实现。
线性表在顺序结构上各种操作的实现题目1:(线性表顺序存储结构上的操作—Delete )从顺序存储结构的线性表a 中删除第i个元素起的k个元素。
(《数据结构题集C语言版》P16)题目2:(线性表顺序存储结构上的操作_lnsert )设顺序表va中的数据元素递增有序。
试写一算法,将x插入到循序表的适当位置上,以保持该表的有序性。
(《数据结构题集C语言版》P17)题目3:(线性表顺序存储结构上的操作_逆置)试写一算法,实现顺序表的就地逆置,即利用原表的存储空间将线性表逆置。
(《数据结构题集C语言版》2.21)线性表线性链表的各种操作题目1:( Insert )试写一算法,在无头结点的动态单链表上实现线性表的Insert(L,i,b), 并和在带头结点的动态单链表上实现同样操作的算法进行比较。
(《数据结构题集C语音版》P17)题目2:(Delete )同上题要求,实现线性表操作Delete(L,i).题目3:已知线性表中的元素以值递增有序排序,并以单链表作为存储结构。
试写一高效算法,删除表中所有值大于mink且小于maxk的元素(若表中存在这样的元素)同时释放被删除结点空间,并分析你的算法的事件复杂度(注意:mink和maxk是给定的两个参变量,它们的值可以和表中的元素相同,也可以不同)。
(《数据结构题集C语言版》P17)题目4:同上题条件,试写一高效算法,删除表中所有值相同的多余元素(使得操作后的线性表所有元素的值均不相同),同是释放被删结点空间,并分析你算法的时间复杂度。
2010年硕士研究生入学考试“数据结构与C语言程序设计”试题与答案
13.C 语言规定,简单变量做实参时,它和对应的形参之间的数据传递方式是 A.单向值传递 B.地址传递 C.由实参传给形参,再由形参传回给实参 D.由用户指定传递方式 14.C 语言规定,函数返回值的类型是由 A.return 语句中的表达式的类型所决定 B.调用该函数时的主函数的类型所决定 。
3
C.调用该函数时系统临时决定 D.在定义该函数时所指定的函数的类型所决定 15.下面给出的 4 个定义语句中,与 int *p[5]; 等价的是 。 A.int p[5]; B.int *p; C.int *(p[5]); 16.若有以下定义和语句,则值为 1002 的表达式是 。 struct s{ int age; int num; }; static struct s a[3]={1001,20,1002,19,1003,21},*ptr; ptr=a; A.ptr++->num B.(ptr++)->age C.(*ptr).num D.(*++ptr).age 17.若要通过下面的程序段使得指针变量指向一个存储整型变量的动态存储单元,则程序段中的空 。 白处(横线上方)应该是 int *ptr; ptr= malloc(sizeof(int)); A.int B.int * C.(int *) D.(*int ) 。 18.下面关于宏的叙述中,错误的是 A.宏名无类型,其参数也无类型 B.宏定义不是 C 语句,不必在行的末尾加分号 C.宏替换只是字符替换 D.宏定义命令必须写在文件的开头 。 19.下列关于 C 语言文件操作的叙述中,正确的是 A.对文件的操作必须是先打开文件 B.对文件的操作必须是先关闭文件 C.对文件操作之前必须先测试文件是否已打开,然后再打开文件 D.对文件的操作无顺序要求 20.使用 fopen( )函数以文本方式打开或者建立可读写文件。要求:若指定文件不存在,则建立一 个文件,并使文件指针指向其开头;若指定文件存在,则打开该文件,并将文件指针指向其结尾。下列 。 “文件使用方式”中,正确的是 A.“r+” B.“ a+” C.“ w+” D.“a”
数据结构试卷一及答案
习题一一、选择题 ( 每小题 2 分,共 20 分 )1.以下程序段的时间复杂度为()。
i=0,s=0; while (s<n) {s=s+i;i++;}(A) O(n/2) (B) O(n/3) (C) O(n) (D) O(n2)2.设某链表中最常用的操作是在链表的尾部插入或删除元素,则选用以下()存储方式最节省运算时间。
(A) 单向链表 (B) 单向循环链表 (C) 双向链表 (D) 双向循环链表3.设指针q指向单链表中结点A,指针p指向单链表中结点A的后继结点B,指针s 指向被插入的结点X,则在结点A和结点B插入结点X的操作序列为()。
(A) s->next=p->next;p->next=-s; (B) q->next=s; s->next=p;(C) p->next=s->next;s->next=p;(D) p->next=s;s->next=q;4.设输入序列为1、2、3、4、5、6,则通过栈的作用后可以得到的输出序列为()。
(A) 5,3,4,6,1,2 (B) 3,2,5,6,4,1(C) 3,1,2,5,4,6 (D) 1,5,4,6,2,35.设有一个10阶的下三角矩阵A(包括对角线),按照从上到下、从左到右的顺序存储到连续的55个存储单元中,每个数组元素占1个字节的存储空间,则A[5][4]地址与A[0] [0]的地址之差为()。
(A) 10 (B) 19 (C) 28 (D) 556.设一棵m叉树中有N1个度数为1的结点,N2个度数为2的结点,……,Nm个度数为m的结点,则该树中共有()个叶子结点。
7. 二叉排序树中左子树上所有结点的值均()根结点的值。
(A) < (B) > (C) = (D) !=8. 设一组权值集合W=(15,3,14,2,6,9,16,17),要求根据这些权值集合构造一棵哈夫曼树,则这棵哈夫曼树的带权路径长度为()。
数据结构实验报告
数据结构实验报告一、实验目的数据结构是计算机科学中的重要基础课程,通过实验可以更深入地理解和掌握数据结构的概念、原理和应用。
本次实验的主要目的包括:1、熟悉常见的数据结构,如链表、栈、队列、树和图等。
2、掌握数据结构的基本操作,如创建、插入、删除、遍历等。
3、提高编程能力和解决实际问题的能力,能够运用合适的数据结构解决具体的问题。
二、实验环境本次实验使用的编程语言为C++,开发环境为Visual Studio 2019。
三、实验内容1、链表的实现与操作单向链表的创建、插入和删除节点。
双向链表的实现和基本操作。
循环链表的特点和应用。
2、栈和队列的实现栈的后进先出特性,实现入栈和出栈操作。
队列的先进先出原则,完成入队和出队功能。
3、树的操作二叉树的创建、遍历(前序、中序、后序)。
二叉搜索树的插入、查找和删除操作。
4、图的表示与遍历邻接矩阵和邻接表表示图。
深度优先搜索和广度优先搜索算法的实现。
四、实验步骤及结果1、链表的实现与操作单向链表:首先,定义了链表节点的结构体,包含数据域和指向下一个节点的指针域。
通过创建链表头节点,并使用循环依次插入新节点,实现了链表的创建。
插入节点时,根据指定位置找到插入点的前一个节点,然后修改指针完成插入操作。
删除节点时,同样找到要删除节点的前一个节点,修改指针完成删除。
实验结果:成功创建、插入和删除了单向链表的节点,并正确输出了链表的内容。
双向链表:双向链表节点结构体增加了指向前一个节点的指针。
创建、插入和删除操作需要同时维护前后两个方向的指针。
实验结果:双向链表的各项操作均正常,能够双向遍历链表。
循环链表:使链表的尾节点指向头节点,形成循环。
在操作时需要特别注意循环的边界条件。
实验结果:成功实现了循环链表的创建和遍历。
2、栈和队列的实现栈:使用数组或链表来实现栈。
入栈操作将元素添加到栈顶,出栈操作取出栈顶元素。
实验结果:能够正确进行入栈和出栈操作,验证了栈的后进先出特性。
数据结构(c)测试
A BC D、下列函数中,时间复杂度最小的是________。
A BC D、栈和队列属于________逻辑结构。
A BC D一个算法所需时间由下述递归方程表示,该算法的时间复杂度是________。
A BC D为正整数,下列程序段的时间复杂度是________。
A BC DB、数据项是数据中不可分割的最小标识单位C、数据可由若干个数据元素组成D、数据项可由若干个数据元素组成3、算法分析的主要方面是________。
A、时间复杂度B、空间复杂度C、数据复杂性D、程序复杂性4、一个"好"的算法应达到的目标有________。
A、正确性B、可行性C、可读性D、健壮性E、高效与低存储量F、确定性5、研究数据结构就是研究________。
A、数据的逻辑结构B、数据的物理结构C、数据在运算上的实现D、数据的复杂度第三题、判断题(每题1分,5道题共5分)1、任何数据结构都具备三个基本运算:插入、删除和查找。
()正确错误2、数据元素可以由很多数据项组成。
()正确错误正确错误、算法分析的目的是研究算法中输入和输出的关系。
(正确错误、在计算机科学中,数据的含义可以很广泛,图像、声音等都可以通过编码的形式而归之于数据的范畴。
正确错误第二章A BC D、在一个单链表中,在所指结点应执行________。
A BC D个元素的单链表中插入或删除一个元素的算法的时间复杂度为________。
A BC D个元素的单链表,其算法的时间复杂度为________。
A BC D个元素的有序单链表,其算法的时间复杂度为________。
A BC DB、顺序存取C、逻辑相邻的元素物理位置也相邻D、元素的物理位置可以相邻也可以不相邻2、单链表的特点是________。
A、随机存取B、顺序存取C、逻辑相邻的元素物理位置也相邻D、元素的物理位置可以相邻也可以不相邻3、在双向循环链表(L为头指针)中,指针p所指结点为尾结点的条件是________。
数据结构实验C语言版
数据结构实验C语言版数据结构实验C语言版文档一、实验目的本实验旨在通过实践操作,加深对C语言中数据结构的理解,掌握常用数据结构的实现方法,提高编程能力。
二、实验内容本实验共包含以下几个章节:1.线性表1.1 顺序表的实现1.2 链表的实现1.3 环形链表的实现2.栈与队列2.1 栈的实现2.2 队列的实现3.树与图3.1 二叉树的实现与遍历3.2 图的实现与遍历4.排序与查找4.1 冒泡排序4.2 快速排序4.3 二分查找5.其他常用数据结构5.1 哈希表5.2 AVL树5.3 并查集三、实验步骤1.线性表1.1 顺序表的实现- 定义顺序表结构体 - 初始化顺序表- 插入元素- 删除元素- 查找元素1.2 链表的实现- 定义链表结构体- 初始化链表- 插入节点- 删除节点- 查找节点1.3 环形链表的实现- 定义环形链表结构体 - 初始化环形链表- 插入节点- 删除节点- 查找节点2.栈与队列2.1 栈的实现- 定义栈结构体- 初始化栈- 入栈操作- 出栈操作- 获取栈顶元素2.2 队列的实现- 定义队列结构体- 初始化队列- 入队操作- 出队操作- 获取队首元素3.树与图3.1 二叉树的实现与遍历 - 定义二叉树结构体 - 创建二叉树- 先序遍历- 中序遍历- 后序遍历3.2 图的实现与遍历- 定义图结构体- 创建图- 广度优先搜索- 深度优先搜索4.排序与查找4.1 冒泡排序- 实现冒泡排序算法- 对数组进行排序4.2 快速排序- 实现快速排序算法- 对数组进行排序4.3 二分查找- 实现二分查找算法- 在有序数组中查找指定元素5.其他常用数据结构5.1 哈希表- 定义哈希表结构体- 初始化哈希表- 插入元素- 删除元素- 查找元素5.2 AVL树- 定义AVL树结构体- 插入节点- 删除节点- 查找节点5.3 并查集- 定义并查集结构体- 初始化并查集- 合并集合- 查找根节点四、附件本文档未涉及附件。
数据结构复习资料(题目和参考答案)
数据结构复习题及参考答案(抽考其中50%)一、单选题(每小题1分)1.下列程序段的时间复杂度为(A )。
for(i=0; i<m ; i++)for(j=0; j<t ; j++) c[i][j]=0;for(i=0; i<m ; i++)for(j=0; j<t ; j++)for(k=0; k<n ; k++)c[i][j]=c[i][j]+a[i][k]*b[k][j];(A) O(m*n*t) (B) O(m+n+t) (C) O(m+n*t) (D) O(m*t+n)2.下列程序段的时间复杂度为(A )。
i=0,s=0;while (s<n) {s=s+i ;i++;}(A) O(n 1/2) (B) O(n 1/3) (C) O(n) (D) O(n 2)3.设顺序表中有n 个数据元素,则删除表中第i 个元素需要移动(A )个元素。
(A) n-i (B) n+l-i (C) n-1-i (D) i4.设某链表中最常用的操作是在链表的尾部插入或删除元素,则选用下列(D )存储方式最节省运算时间。
(A) 单向链表 (B) 单向循环链表(C) 双向链表 (D) 双向循环链表5.设F 是由1T 、2T 和3T 三棵树组成的森林,与F 对应的二叉树为B ,1T 、2T 和3T 的结点数分别为1n 、2n 和3n ,则二叉树B 的根结点的左子树的结点数为(A )。
(A) 11n - (B) 21n - (C) 23n n + (D) 13n n +6.设指针q 指向单链表中结点A ,指针p 指向单链表中结点A 的后继结点B ,指针s 指向被插入的结点X ,则在结点A 和结点B 插入结点X 的操作序列为(B )。
(A) s->next=p->next ;p->next=-s ; (B) q->next=s ; s->next=p ;(C) p->next=s->next ;s->next=p ; (D) p->next=s ;s->next=q ;7.利用直接插入排序法的思想建立一个有序线性表的时间复杂度为(C )。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
//在Doublelinkedlist.h内#include"utility.h"#include<iostream>using namespace std;template <class Node_entry>struct Node{Node_entry entry;Node <Node_entry> *next;Node <Node_entry> *back;Node();Node(Node_entry x ,Node<Node_entry> *link_back =NULL ,Node<Node_entry> *link_next =NULL);};template <class Node_entry>Node<Node_entry>::Node(){next = NULL;back = NULL;}template <class Node_entry>Node<Node_entry>::Node(Node_entry x ,Node<Node_entry> *link_back , Node<Node_entry> *link_next ) {entry = x;next = link_next;back = link_back;}template <class List_entry>class List{public:List();void clear();bool empty() const;bool full() const;int size() const;Error_code insert(int position, const List_entry & x);Error_code remove(int position, List_entry & x);Error_code retrieve(int position,List_entry &x) const;Error_code replace (int position,const List_entry &x); protected:int count;mutable int current_position;mutable Node<List_entry> *current ;void set_position(int pisition) const;};template <class List_entry>List<List_entry>::List(){count = 0;current_position = 0;current = NULL;}template <class List_entry>void List<List_entry>::clear (){List_entry temp;for(int i = 0; i<count ; i++){remove(i, temp);}return ;}template <class List_entry>bool List<List_entry>::empty() const{return count == 0;}template <class List_entry>bool List<List_entry>::full () const{return false;}template <class List_entry>int List<List_entry> ::size() const{return count;}template <class List_entry>void List<List_entry> ::set_position(int position) const{if(current_position<=position)for(; current_position!=position;current_position++)current = current->next ;elsefor(;current_position !=position; current_position--)current=current->back ;return ;}template <class List_entry>Error_code List<List_entry>::insert(int position, const List_entry &x) {Node<List_entry> *new_node , *following , *preceding;if(position<0 || position >count)return Error_code::range_error;if(position ==0){if(count==0)following =NULL;else{set_position(0);following =current;}preceding =NULL;}else{set_position(position-1);preceding = current;following = preceding->next ;}new_node = new Node<List_entry> (x,preceding,following);if(new_node ==NULL)return overflow;if(preceding !=NULL)preceding->next = new_node;if(following !=NULL)following ->back =new_node;current = new_node;current_position = position;count++;return success;};template <class List_entry>Error_code List<List_entry>::remove(int position, List_entry &x) {Node<List_entry> *dele_node , *following , *preceding;if(position<0 || position >=count)return range_error;if( position == 0 ){set_position(0);dele_node = current;following = dele_node ->next;following->back = NULL;x = dele_node->entry;delete dele_node;count--;return success;}if(position ==count-1){set_position(position-1);preceding = current;dele_node = current->next;preceding->next = NULL;x = dele_node->entry;delete dele_node;count--;return sucess;}else{set_position(position-1);preceding = current;dele_node = current->next;following = dele_node->next;preceding->next = following;following->back = preceding;x = dele_node->entry;delete dele_node;count--;return sucess;}}template <class List_entry>Error_code List<List_entry>::retrieve(int position, List_entry &x) const {if(position<0 || position >=count)return Error_code::range_error;set_position(position);x=current->entry;return success;}template <class List_entry>Error_code List<List_entry>::replace(int position,const List_entry &x) {if(position<0 || position >=count)return range_error;set_position(position);current->entry = x;return success;}//main.cpp内#include"Doublelinkedlist.h"#include"utility.h"#include<iostream>using namespace std;int main(){List<int> the_double_list;int x;for(int i=0;i<10;i++){the_double_list.insert (i,10-i);}for(int i=0;i<10;i++){the_double_list.retrieve (i,x);cout<<x<<endl;}return 0;}。