顺序表及链表的应用
数据结构中顺序表与链表的性能方面比较
数据结构中顺序表与链表的性能⽅⾯⽐较
⼀,时间性能的⽐较
顺序表由数组实现,是⼀种随机存取结构,对表中任意节点存取操作时间复杂度为O(1)。
⽽查找链表的节点,须从头指针开始沿链扫描,平均时间复杂度为O(N).因此,若线性表的操作主要是查找,很少进⾏插⼊或删除操作,采⽤顺序⽐较合适。
对于链表,对某个节点进⾏插⼊删除操作只需修改指针,⽆需⼤量移动元素,平均时间复杂度为O(1)。
⽽顺序表在插⼊或删除时,需要⼤量移动数据元素,平均移动元素的数⽬为表长的⼀般,时间复杂度为O(N)。
因此,对线性表频繁的进⾏插⼊删除操作时,应采⽤链表。
当插⼊和删除主要在表头或表尾时,应采⽤循环链表。
表1:时间性能⽐较
时间复杂度查找插⼊或删
除
顺序表O(1)O(N)
链表O(N)O(1)
⼆,空间性能的⽐较
1,顺序表的存储空间是静态分配的,必须提前确定其内存⼤⼩。
常⽤于存储规模容易确定的线性表。
2,动态链表的存储空间是动态分配的,只要其内存空间有空闲就不会出现溢出。
常⽤于长度变化较⼤或长度难以估计的线性表。
3,定义:存储密度=(节点中数据域占⽤的空间)/(节点结构占⽤的存储空间)
有时需考虑存储密度。
综上,在选取线性表时,应综合考虑时间和空间因素,选择⼀中最适合的。
⼀般⽽⾔,顺序表适⽤于查询,⽽链表则更便于插⼊删除管理。
链表及其应用
头指针是指向链表中第一个结点(或为头结点或为首
元素结点)的指针。 单链表可由一个头指针唯一确定。
头结点是在链表的首元素结点之前附设的一个结点;
数据域内只放空表标志和表长等信息;
首元素结点是指链表中存储线性表第一个数据元素
a1的结点。
33
第3章 链表及其应用
讨论1. 在链表中设置头结点有什么好处?
我们可以用结构体来定义静态链表的节点数据类型: typedef struct{ Datatype data; int next; }node;
一个静态链表可以描述为: #define maxsize 100 node nodepool[maxsize];//存放链表的数组 int head; //放头指针的head 在静态链表中进行插入与删除操作不需要移动元素,
4
第3章 链表及其应用
3.1 链表的基本概念
3.1.1 什么是链表 ☞ 3.1.2 链表的逻辑结构
3.1.3 链表的存储结构 3.1.4 静态链表和动态链表 3.1.5 链表的基本运算
5
第3章 链表及其应用
♣ 链表的逻辑结构
☞ 同一链表中所有数据元素的数据类型必须相同。 ☞ 链表中相邻的元素ai-1、ai间存在序偶关系,即 对于非空的链表,ai-1是ai的唯一直接前驱,ai+1是 ai的唯一直接后继;而a1无前驱,an无后继 ☞ 链表属于线性逻辑结构。
结点3的地址:p->next;
28
第3章 链表及其应用
H
a1
p
p
a2
a3
a4
a5 ∧
再令p = p->next, 数据元素a3值:p ->data
结点4的地址:p->next;
chap2数据结构,顺序表,树,图,链表,排序
2.4 一元多项式的表示
ADT List { 数据对象: D={ ai | ai ∈ElemSet, i=1,2,...,n, n≥0 } { 称 n 为线性表的表长; 称 n=0 时的线性表为空表。} 数据关系:
R1={ <ai-1 ,ai >|ai-1 ,ai∈D, i=2,...,n }
{ 设线性表为 (a1,a2, . . . ,ai,. . . ,an), 称 i 为 ai 在线性表中的位序。}
i = 1; found = TRUE; while ( i<= La_len && found ) {
GetElem(LA, i, e); // 取得LA中一个元素
if (LocateElem(LB, e, equal( ))
i++;
// 依次处理下一个
else found = FALSE;
// LB中没有和该元素相同的元素
{加工型操作} ClearList( &L ) ( 线性表置空 ) PutElem( &L, i, &e ) ( 改变数据元素的值 ) ListInsert( &L, i, e ) ( 插入数据元素 ) ListDelete( &L, i, &e ) ( 删除数据元素 )
ClearList( &L ) 初始条件:线性表 L 已存在。 操作结果:将 L 重置为空表。 PutElem( &L, i, e ) 初始条件: 线性表 L 已存在, 且 1≤i≤LengthList(L)。 操作结果:L 中第 i 个元素赋值和 e 相同。
线性结构的基本特征: 线性结构 是 一个数据元素的有序(次序)集 1.集合中必存在唯一的一个“第一元素” 2.集合中必存在唯一的一个 “最后元素”
算法与及数据结构实验报告
算法与及数据结构实验报告算法与数据结构实验报告一、实验目的本次算法与数据结构实验的主要目的是通过实际操作和编程实现,深入理解和掌握常见算法和数据结构的基本原理、特性和应用,提高我们解决实际问题的能力和编程技巧。
二、实验环境本次实验使用的编程语言为 Python,开发环境为 PyCharm。
同时,为了进行算法性能的分析和比较,使用了 Python 的 time 模块来计算程序的运行时间。
三、实验内容1、线性表的实现与操作顺序表的实现:使用数组来实现顺序表,并实现了插入、删除、查找等基本操作。
链表的实现:通过创建节点类来实现链表,包括单向链表和双向链表,并完成了相应的操作。
2、栈和队列的应用栈的实现与应用:用数组或链表实现栈结构,解决了表达式求值、括号匹配等问题。
队列的实现与应用:实现了顺序队列和循环队列,用于模拟排队系统等场景。
3、树结构的探索二叉树的创建与遍历:实现了二叉树的先序、中序和后序遍历算法,并对其时间复杂度进行了分析。
二叉搜索树的操作:构建二叉搜索树,实现了插入、删除、查找等操作。
4、图的表示与遍历邻接矩阵和邻接表表示图:分别用邻接矩阵和邻接表来存储图的结构,并对两种表示方法的优缺点进行了比较。
图的深度优先遍历和广度优先遍历:实现了两种遍历算法,并应用于解决路径查找等问题。
5、排序算法的比较插入排序、冒泡排序、选择排序:实现了这三种简单排序算法,并对不同规模的数据进行排序,比较它们的性能。
快速排序、归并排序:深入理解并实现了这两种高效的排序算法,通过实验分析其在不同情况下的表现。
6、查找算法的实践顺序查找、二分查找:实现了这两种基本的查找算法,并比较它们在有序和无序数据中的查找效率。
四、实验步骤及结果分析1、线性表的实现与操作顺序表:在实现顺序表的插入操作时,如果插入位置在表的末尾或中间,需要移动后续元素以腾出空间。
删除操作同理,需要移动被删除元素后面的元素。
在查找操作中,通过遍历数组即可完成。
工作报告之约瑟夫环实验报告总结
约瑟夫环实验报告总结【篇一:约瑟夫环实验报告】实验报告课程名称:数据结构实验名称:顺序表和链表的应用实验编号:实验一指导教师:一、实验目的(1)掌握线性表的基本操作(插入、删除、查找)以及线性表合并等运算在顺序存储结构、链式存储结构上的实现。
重点掌握链式存储结构实现的各种操作。
(2)掌握线性表的链式存储结构的应用。
二、实验内容与实验步骤(1)实验内容:实现约瑟夫环,约瑟夫环(joseph)问题的一种描述是:编号为1、2、3……n的n个人按照顺时针方向围坐一圈,每人持有一个密码(正整数)。
一开始任选一个正整数作为报数的上限值m,从第一个人开始按照顺时针的方向自1开始顺序报数,报到m时停止报数。
报m的人出列,将他的密码作为新的m值,从他的顺时针方向上的下一个人开始重新从1报数,如此下去,直至所有人全部出列为止。
设计一个程序求出出列顺序。
(2)抽象数据类型和设计的函数描述,说明解决设想。
首先定义一个链表,用其中的data项存储每个人的编号,用password项存储每个人所持有的密码,并且声明一个指针。
之后使用creatlist_cl函数来创建一个循环链表,在其中的data和password中存入编号和密码,最后使最后一个节点的next指向l,使其能够形成循环队列。
定义了函数display来显示链表当中的内容,以确定存储的数据没有错误。
定义了函数delete_l来实现约瑟夫环中依次删除的功能,依次比较,如果某个人所持的密码和m值相等,则删除这个结点,并且输出此时该结点的编号和密码,实现出列的功能。
(3)简短明确地写出实验所采用的存储结构,并加以说明。
该实验我主要采用的是线性表的链式存储结构,首先定义了链表的结构,其中包括data项和password项,分别存储每个人的编号和所持密码,还声明了指向下一个结点的指针,该指针可以连接各个结点,并且将最后一个结点的指针指向第一个结点使之成为一个循环链表。
三、实验环境操作系统:windows 7调试软件名称:vc++版本号:6.0上机地点:综合楼311四、实验过程与分析(1)主要的函数或操作内部的主要算法,分析这个算法的时、空复杂度,并说明设计的巧班级:学号:姓名:组号:实验成绩:批阅教师签字:实验日期:实验时间:妙之处。
数据结构实验(使用版)
实验一顺序表的应用一.实验目的1、掌握线性表的顺序存储结构的基本操作的实现。
2、设计并实现顺序表的应用程序,提高编程能力。
二.实验内容编写程序实现:1、在原来的顺序表中将顺序表实现逆置。
2、要求顺序表的内容由用户输入,并分别显示出逆置前和逆置后的顺序表。
三.实验设备及实验环境实验设备:微机一台实验环境:C语言运行环境实验二单链表的应用三.实验目的1、掌握线性表的链式存储结构的基本操作的实现。
2、设计并实现单链表的应用程序,提高编程能力。
四.实验内容编写程序实现:1、在原有的单链表中,将单链表实现逆置。
(即不增加新的结点)2、程序要求单链表的内容由用户输入,并分别显示出逆置前和逆置后的单链表。
三.实验设备及实验环境实验设备:微机一台实验环境:C语言运行环境实验三栈和队列的应用一.实验目的1、掌握栈和队列的基本操作的实现。
2、利用栈和队列的特点解决实际问题,提高编程能力。
二.实验内容(1是必做题目,2和3可选其一)编写两个程序分别实现:1、进制之间的转换:如将10进制转换为2进制,10进制数n和要转换的进制d通过键盘输入。
2、利用栈解决火车调度问题,将本来杂乱无章的车厢排成软席(S)在前,硬席(H)在后。
车厢序列通过键盘输入,如HSHSHSSSH,输出SSSSSHHHH。
3、利用队列模拟医院排队系统。
三.实验设备及实验环境实验设备:微机一台实验环境:C语言运行环境实验四二叉树的操作(一)一、实验目的1、熟悉二叉树的概念和存储结构。
2、掌握二叉树的基本操作和实现方法。
二.实验内容1、利用栈并且采用非递归先序算法建立二叉树。
2、要求通过键盘输入二叉树的先序遍历顺序从而建立一棵二叉树。
三.实验设备及实验环境实验设备:微机一台实验环境:C语言运行环境实验五二叉树的基本操作(二)一、实验目的1.熟悉二叉树的遍历方法。
2.掌握非递归中序遍历、先序遍历和后序遍历算法的实现。
二.实验内容(中序非递归遍历必做、先序和后序可选其一)1、在前一实验的基础上,利用栈实现一棵二叉树的非递归遍历。
顺序表与链表的比较
顺序表与链表的比较一、顺序表的特点是逻辑上相邻的数据元素,物理存储位置也相邻,并且,顺序表的存储空间需要预先分配。
它的优点是:(1)方法简单,各种高级语言中都有数组,容易实现。
(2)不用为表示节点间的逻辑关系而增加额外的存储开销。
(3)顺序表具有按元素序号随机访问的特点。
缺点:(1)在顺序表中做插入、删除操作时,平均移动表中的一半元素,因此对n较大的顺序表效率低。
(2)需要预先分配足够大的存储空间,估计过大,可能会导致顺序表后部大量闲置;预先分配过小,又会造成溢出。
二、在链表中逻辑上相邻的数据元素,物理存储位置不一定相邻,它使用指针实现元素之间的逻辑关系。
并且,链表的存储空间是动态分配的。
链表的最大特点是:插入、删除运算方便。
缺点:(1)要占用额外的存储空间存储元素之间的关系,存储密度降低。
存储密度是指一个节点中数据元素所占的存储单元和整个节点所占的存储单元之比。
(2)链表不是一种随机存储结构,不能随机存取元素。
三、顺序表与链表的优缺点切好相反,那么在实践应用中怎样选取存储结构呢?通常有以下几点考虑:(1)顺序表的存储空间是静态分配的,在程序执行之前必须明确规定它的存储规模,也就是说事先对“MaxSize”要有合适的设定,设定过大会造成存储空间的浪费,过小造成溢出。
因此,当对线性表的长度或存储规模难以估计时,不宜采用顺序表。
然而,链表的动态分配则可以克服这个缺点。
链表不需要预留存储空间,也不需要知道表长如何变化,只要内存空间尚有空闲,就可以再程序运行时随时地动态分配空间,不需要时还可以动态回收。
因此,当线性表的长度变化较大或者难以估计其存储规模时,宜采用动态链表作为存储结构。
但在链表中,除数据域外海需要在每个节点上附加指针。
如果节点的数据占据的空间小,则链表的结构性开销就占去了整个存储空间的大部分。
当顺序表被填满时,则没有结构开销。
在这种情况下,顺序表的空间效率更高。
由于设置指针域额外地开销了一定的存储空间,从存储密度的角度来讲,链表的存储密度小于1.因此,当线性表的长度变化不大而且事先容易确定其大小时,为节省存储空间,则采用顺序表作为存储结构比较适宜。
数据结构舞伴问题课程设计
数据结构舞伴问题课程设计一、课程目标知识目标:1. 理解舞伴问题在数据结构中的背景及应用,掌握其基本概念与算法原理;2. 学会运用顺序表和链表两种数据结构解决舞伴问题,并掌握其优缺点;3. 能够运用所学知识,解决类似舞伴问题的其他实际应用问题。
技能目标:1. 培养学生运用数据结构解决实际问题的能力,提高编程技能;2. 培养学生分析问题、设计算法、编写程序及调试程序的能力;3. 培养学生通过合作、交流、分享等方式,提高团队协作能力。
情感态度价值观目标:1. 培养学生对数据结构的兴趣,激发学生学习算法的积极性;2. 培养学生勇于面对问题、克服困难的信心和决心,形成良好的学习习惯;3. 培养学生具备解决问题的责任心和使命感,认识到数据结构在信息技术领域的重要作用。
分析课程性质、学生特点和教学要求,本课程目标旨在让学生掌握舞伴问题及相关数据结构知识,培养其编程技能和团队协作能力。
通过本课程的学习,学生能够运用所学知识解决实际问题,提高自身综合素质,为未来的学习和发展打下坚实基础。
二、教学内容本课程以《数据结构》教材中舞伴问题相关章节为基础,组织以下教学内容:1. 舞伴问题背景介绍:阐述舞伴问题的实际应用场景,使学生了解其在信息技术领域的意义。
2. 数据结构基本概念:回顾线性表、顺序表和链表等基本数据结构,为解决舞伴问题打下基础。
3. 舞伴问题算法原理:介绍舞伴问题的算法原理,包括配对过程、算法步骤等。
4. 顺序表和链表的应用:详细讲解如何使用顺序表和链表解决舞伴问题,分析两种方法的优缺点。
5. 编程实践:引导学生运用所学知识编写程序,解决舞伴问题,并调试优化。
6. 实例分析:分析舞伴问题在其他领域的应用,提高学生运用知识解决实际问题的能力。
教学大纲安排如下:1. 第一周:舞伴问题背景介绍,数据结构基本概念回顾;2. 第二周:舞伴问题算法原理,顺序表和链表的应用;3. 第三周:编程实践,分组讨论与交流;4. 第四周:实例分析,总结与拓展。
顺序与链表综合比较
第12讲顺序与链表综合比较顺序表和链表这两种存储表示方法各有优缺点。
在实际应用中究竟选用哪一种存储结构呢?这要根据具体的要求和性质决定。
顺序表和链表的比较1.基于空间的考虑顺序表的存储空间是静态分配的,在程序执行之前必须明确规定它的存储规模。
若线性表的长度n变化较大,则存储规模难于预先确定。
估计过大将造成空间浪费,估计太小又将使空间溢出的机会增多。
在静态链表中,初始存储池虽然也是静态分配的,但若同时存在若干个结点类型相同的链表,则它们可以共享空间,使各链表之间能够相互调节余缺,减少溢出机会。
动态链表的存储空间是动态分配的,只要内存空间尚有空闲,就不会产生溢出。
因此,当线性表的长度变化较大,难以估计其存储规模时,采用动态链表作为存储结构较好。
存储密度(Storage Density)是指结点数据本身所占的存储量和整个结点结构所占的存储量之比,即:存储密度=结点数据本身所占的存储量/结点结构所占的存储总量链表中的每个结点,除了数据域外,还要额外设置指针(或游标)域,从存储密度来讲,这是不经济的。
一般地,存储密度越大,存储空间的利用率就高。
显然,顺序表的存储密度为1,而链表的存储密度小于1。
例如单链表的结点的数据均为整数,指针所占空间和整型量相同,则单链表的存储密度为50%。
因此若不考虑顺序表中的备用结点空间,则顺序表的存储空间利用率为100%,而单链表的存储空间利用率为50%。
由此可知,当线性表的长度变化不大,易于事先确定其大小时,为了节约存储空间,宜采用顺序表作为存储结构。
2.基于时间的考虑顺序表是由向量实现的,它是一种随机存取结构,对表中任一结点都可以在O(1) 时间内直接地存取,而链表中的结点,需从头指针起顺着链找才能取得。
因此,若线性表的操作主要是进行查找,很少做插入和删除时,宜采用顺序表做存储结构。
在链表中的任何位置上进行插入和删除,都只需要修改指针。
而在顺序表中进行插入和删除,平均要移动表中近一半的结点,尤其是当每个结点的信息量较大时,移动结点的时间开销就相当可观。
线性表顺序存储与链式存储的比较
• • 但在链表中,除数据域外还需要在每个节点上附加指 针。如果节点的数据占据的空间小,则链表的结构性开销 就占去了整个存储空间的大部分。当顺序表被填满时,则 没有结构开销。在这种情况下,顺序表的空间效率更高。 由于设置指针域额外地开销了一定的存储空间,从存储密 度的角度来讲,链表的存储密度小于1.因此,当线性表的 长度变化丌大而且事先容易确定其大小时,为节省存储空 间,则采用顺序表作为存储结构比较适宜。
实践应用
(1)顺序表的存储空间是静态分配的,在程序执行之前必 须明确规定它的存储规模,也就是说事先对“MaxSize” 要有合适的设定,设定过大会造成存储空间的浪费,过小 造பைடு நூலகம்溢出。因此,当对线性表的长度或存储规模难以估计 时,丌宜采用顺序表。然而,链表的动态分配则可以克服 这个缺点。链表丌需要预留存储空间,也丌需要知道表长 如何变化,只要内存空间尚有空闲,就可以再程序运行时 随时地动态分配空间,丌需要时还可以动态回收。因此, 当线性表的长度变化较大或者难以估计其存储规模时,宜 采用动态链表作为存储结构。
•
基于运算的考虑(时间)
• 顺序存储是一种随机存取的结构,而链表则是一种顺序存 取结构,因此它们对各种操作有完全丌同的算法和时间复 杂度。例如,要查找线性表中的第i个元素,对于顺序表可 以直接计算出a(i)的的地址,丌用去查找,其时间复杂度 为0(1).而链表必须从链表头开始,依次向后查找,平均需 要0(n)的时间。所以,如果经常做的运算是按序号访问数 据元素,显然顺表优于链表。 • 反之,在顺序表中做插入,删除时平均移动表中一半 的元素,当数据元素的信息量较大而且表比较长时,这一 点是丌应忽视的;在链表中作插入、删除,虽然要找插入 位置,但操作是比较操作,从这个角度考虑显然后者优于 前者。
线性表之顺序表与单链表的区别及优缺点
线性表之顺序表与单链表的区别及优缺点线性表主要有顺序表和链表两种存储形式,贴主想问的,应该是将线性表la和l b头尾连接,要求时间复杂度为o(1),且占用辅助空间尽量小.应该使用哪种存储形式对吧?答案是应当采用链表。
具体理由看文章。
这里比较的是基于C语言实现的顺序表与单链表,与其他语言的实现可能会有差异,但我相信语言是相通的,它们的实现机制应该也差不多。
1、What什么是顺序表和单链表①顺序表:顺序表是在计算机内存中以数组的形式保存的线性表,是指用一组地址连续的存储单元依次存储数据元素的线性结构。
只要确定了起始位置,表中任一元素的地址都通过下列公式得到:LOC(ai)=LOC(a1)+(i-1)*L 1≤i≤n 其中,L 是元素占用存储单元的长度。
②单链表:单链表是一种链式存取的数据结构,用一组地址任意的存储单元存放线性表中的数据元素。
它的数据是以结点(类型一般为结构体)来表示的,每个结点的构成:数据(类型为要存储的数据的类型)+ 指针(结构体指针),数据就是链表里具体要存储的东西,指针就是用来把每个节点都连接起来,使它们形成一个链状。
结点:链表:2、Compare二者的优缺点比较①空间上的比较(Space)a. 空间的开辟:顺序表的实现一般是实现连续开辟一段空间,然后在进行数据的增删查改(静态顺序表),所以顺序表一般是固定空间大小的;而单链表则是一次只开辟一个结点的空间,用来存储当前要保存的数据及指向下一个结点或NULL的指针,所以单链表的空间大小时动态变化的。
(当然,顺序表也可以在初始化时利用mallo c函数来开辟一块空间,每当空间不够用时,再用realloc来把当前空间扩容成2倍,从而也能实现空间的动态变化(动态顺序表))。
、b. 空间的使用:当我们不知道要存储多少数据时,用顺序表来开辟的空间如果太大,就会造成一定程度上的浪费,而用单链表是实现时,因为是每需要存储一个数据时,才开辟一个空间,虽然有非数据项的指针占空间,但相比顺序表来说,浪费不是那么明显;反之,当我们知道存储的数据的数量时,用顺序表来开辟对应的空间大小,来存储数据,因为顺序表中每个元素的存储密度为1,就完全不会有浪费的空间,而用单链表,因为每个结点都会有非数据项得指针,那么就会造成空间的浪费。
数据结构c++顺序表、单链表的基本操作,查找、排序代码
} return 0; }
实验三 查找
实验名称: 实验3 查找 实验目的:掌握顺序表和有序表的查找方法及算法实现;掌握二叉排序 树和哈希表的构造和查找方法。通过上机操作,理解如何科学地组织信 息存储,并选择高效的查找算法。 实验内容:(2选1)内容1: 基本查找算法;内容2: 哈希表设计。 实验要求:1)在C++系统中编程实现;2)选择合适的数据结构实现查 找算法;3)写出算法设计的基本原理或画出流程图;4)算法实现代码 简洁明了;关键语句要有注释;5)给出调试和测试结果;6)完成实验 报告。 实验步骤: (1)算法设计 a.构造哈希函数的方法很多,常用的有(1)直接定址法(2)数字分析法;(3) 平方取中法;(4)折叠法;( 5)除留余数法;(6)随机数法;本实验采用的是除 留余数法:取关键字被某个不大于哈希表表长m的数p除后所得余数为哈 希地址 (2)算法实现 hash hashlist[n]; void listname(){ char *f; int s0,r,i; NameList[0].py="baojie"; NameList[1].py="chengቤተ መጻሕፍቲ ባይዱoyang"; ……………………………… NameList[29].py="wurenke"; for(i=0;i<q;i++){s0=0;f=NameList[i].py; for(r=0;*(f+r)!='\0';r++) s0+=*(f+r);NameList[i].k=s0; }} void creathash(){int i;
v[k-1]=v[k]; nn=nn-1; return ; } int main() {sq_LList<double>s1(100); cout<<"第一次输出顺序表对象s1:"<<endl; s1.prt_sq_LList(); s1.ins_sq_LList(0,1.5); s1.ins_sq_LList(1,2.5); s1.ins_sq_LList(4,3.5); cout<<"第二次输出顺序表对象s1:"<<endl; s1.prt_sq_LList(); s1.del_sq_LList(0); s1.del_sq_LList(2); cout<<"第三次输出顺序表对象s1:"<<endl; s1.prt_sq_LList(); return 0; } 运行及结果:
数据结构实验报告-实验一顺序表、单链表基本操作的实现
数据结构实验报告-实验⼀顺序表、单链表基本操作的实现实验⼀顺序表、单链表基本操作的实现l 实验⽬的1、顺序表(1)掌握线性表的基本运算。
(2)掌握顺序存储的概念,学会对顺序存储数据结构进⾏操作。
(3)加深对顺序存储数据结构的理解,逐步培养解决实际问题的编程能⼒。
l 实验内容1、顺序表1、编写线性表基本操作函数:(1)InitList(LIST *L,int ms)初始化线性表;(2)InsertList(LIST *L,int item,int rc)向线性表的指定位置插⼊元素;(3)DeleteList1(LIST *L,int item)删除指定元素值的线性表记录;(4)DeleteList2(LIST *L,int rc)删除指定位置的线性表记录;(5)FindList(LIST *L,int item)查找线性表的元素;(6)OutputList(LIST *L)输出线性表元素;2、调⽤上述函数实现下列操作:(1)初始化线性表;(2)调⽤插⼊函数建⽴⼀个线性表;(3)在线性表中寻找指定的元素;(4)在线性表中删除指定值的元素;(5)在线性表中删除指定位置的元素;(6)遍历并输出线性表;l 实验结果1、顺序表(1)流程图(2)程序运⾏主要结果截图(3)程序源代码#include<stdio.h>#include<stdlib.h>#include<malloc.h>struct LinearList/*定义线性表结构*/{int *list; /*存线性表元素*/int size; /*存线性表长度*/int Maxsize; /*存list数组元素的个数*/};typedef struct LinearList LIST;void InitList(LIST *L,int ms)/*初始化线性表*/{if((L->list=(int*)malloc(ms*sizeof(int)))==NULL){printf("内存申请错误");exit(1);}L->size=0;L->Maxsize=ms;}int InsertList(LIST *L,int item,int rc)/*item记录值;rc插⼊位置*/ {int i;if(L->size==L->Maxsize)/*线性表已满*/return -1;if(rc<0)rc=0;if(rc>L->size)rc=L->size;for(i=L->size-1;i>=rc;i--)/*将线性表元素后移*/L->list[i+=1]=L->list[i];L->list[rc]=item;L->size++;return0;}void OutputList(LIST *L)/*输出线性表元素*/{int i;printf("%d",L->list[i]);printf("\n");}int FindList(LIST *L,int item)/*查找线性元素,返回值>=0为元素的位置,返回-1为没找到*/ {int i;for(i=0;i<L->size;i++)if(item==L->list[i])return i;return -1;}int DeleteList1(LIST *L,int item)/*删除指定元素值得线性表记录,返回值为>=0为删除成功*/ {int i,n;for(i=0;i<L->size;i++)if(item==L->list[i])break;if(i<L->size){for(n=i;n<L->size-1;n++)L->list[n]=L->list[n+1];L->size--;return i;}return -1;}int DeleteList2(LIST *L,int rc)/*删除指定位置的线性表记录*/{int i,n;if(rc<0||rc>=L->size)return -1;for(n=rc;n<L->size-1;n++)L->list[n]=L->list[n+1];L->size--;return0;}int main(){LIST LL;int i,r;printf("list addr=%p\tsize=%d\tMaxsize=%d\n",LL.list,LL.size,LL.Maxsize);printf("list addr=%p\tsize=%d\tMaxsize=%d\n",LL.list,LL.list,LL.Maxsize);while(1){printf("请输⼊元素值,输⼊0结束插⼊操作:");fflush(stdin);/*清空标准输⼊缓冲区*/scanf("%d",&i);if(i==0)break;printf("请输⼊插⼊位置:");scanf("%d",&r);InsertList(&LL,i,r-1);printf("线性表为:");OutputList(&LL);}while(1){printf("请输⼊查找元素值,输⼊0结束查找操作:");fflush(stdin);/*清空标准输⼊缓冲区*/scanf("%d ",&i);if(i==0)break;r=FindList(&LL,i);if(r<0)printf("没有找到\n");elseprintf("有符合条件的元素,位置为:%d\n",r+1);}while(1){printf("请输⼊删除元素值,输⼊0结束查找操作:");fflush(stdin);/*清楚标准缓存区*/scanf("%d",&i);if(i==0)break;r=DeleteList1(&LL,i);if(i<0)printf("没有找到\n");else{printf("有符合条件的元素,位置为:%d\n线性表为:",r+1);OutputList(&LL);}while(1){printf("请输⼊删除元素位置,输⼊0结束查找操作:");fflush(stdin);/*清楚标准输⼊缓冲区*/scanf("%d",&r);if(r==0)break;i=DeleteList2(&LL,r-1);if(i<0)printf("位置越界\n");else{printf("线性表为:");OutputList(&LL);}}}链表基本操作l 实验⽬的2、链表(1)掌握链表的概念,学会对链表进⾏操作。
顺序表的操作实验报告
顺序表的操作实验报告一、实验目的。
1. 了解顺序表的基本概念和操作方法;2. 掌握顺序表的插入、删除、查找等操作;3. 熟悉顺序表的存储结构和实现方式。
二、实验内容。
1. 实现顺序表的基本操作,包括插入、删除、查找等;2. 对比顺序表和链表的优缺点;3. 分析顺序表的存储结构和实现方式。
三、实验原理。
顺序表是一种线性表的存储结构,它的特点是元素之间的逻辑顺序和物理顺序一致,即在内存中连续存储。
顺序表的基本操作包括插入、删除、查找等。
1. 插入操作,在顺序表的某个位置插入一个元素,需要将插入位置后的所有元素向后移动一个位置,然后将新元素插入到指定位置。
2. 删除操作,删除顺序表中的某个元素,需要将删除位置后的所有元素向前移动一个位置,然后将最后一个元素删除。
3. 查找操作,在顺序表中查找某个元素,需要遍历整个顺序表,逐个比较元素的值,直到找到目标元素或者遍历完整个表。
四、实验步骤。
1. 实现顺序表的基本操作,包括插入、删除、查找等;2. 编写测试用例,验证顺序表的功能和正确性;3. 对比顺序表和链表的优缺点,分析其适用场景;4. 分析顺序表的存储结构和实现方式,总结其特点和应用场景。
五、实验结果与分析。
1. 实现了顺序表的基本操作,包括插入、删除、查找等,功能正常;2. 经过测试用例验证,顺序表的功能和正确性得到了验证;3. 对比顺序表和链表的优缺点,发现顺序表的插入、删除操作效率较低,但查找操作效率较高,适合静态查找;4. 分析顺序表的存储结构和实现方式,发现其适用于元素数量较少且频繁查找的场景。
六、实验总结。
通过本次实验,我们深入了解了顺序表的基本概念和操作方法,掌握了顺序表的插入、删除、查找等操作。
同时,我们对比了顺序表和链表的优缺点,分析了顺序表的存储结构和实现方式,加深了对顺序表的理解和应用。
在今后的学习和工作中,我们将根据实验结果的分析,合理选择顺序表或链表作为数据结构,以满足不同场景下的需求。
数据结构实验报告之链表顺序表的操作
数据结构实验报告之链表顺序表的操作1、编写程序实现顺序表的各种基本运算:初始化、插⼊、删除、取表元素、求表长、输出表、销毁、判断是否为空表、查找元素。
在此基础上设计⼀个主程序完成如下功能:(1)初始化顺序表L;(2)依次在表尾插⼊a,b,c,d,e五个元素;(3)输出顺序表L;(4)输出顺序表L的长度;(5)判断顺序表L是否为空;(6)输出顺序表L的第4个元素;(7)输出元素c的位置;(8)在第3个位置上插⼊元素f,之后输出顺序表L;(9)删除L的第2个元素,之后输出顺序表L;(10)销毁顺序表L。
2、编写程序实现单链表的各种基本运算:初始化、插⼊、删除、取表元素、求表长、输出表、销毁、判断是否为空表、查找元素。
在此基础上设计⼀个主程序完成如下功能:(1)初始化单链表L;(2)依次在表尾插⼊a,b,c,d,e五个元素;(3)输出单链表L;(4)输出单链表L的长度;(5)判断单链表L是否为空;(6)输出单链表L的第4个元素;(7)输出元素c的位置;(8)在第3个位置上插⼊元素f,之后输出单链表L;(9)删除L的第2个元素,之后输出单链表L;(10)销毁单链表L。
1顺序表2 #include<stdio.h>3 #include<malloc.h>4 #include<stdlib.h>56#define TRUE 17#define FALSE 08#define OK 19#define ERROR 010#define INFEASIBLE -111#define OVERFLOW -212 typedef int Status;13 typedef char ElemType;1415#define LIST_INIT_SIZE 100 //线性表存储空间的初始分配量16#define LISTINCREMENT 10 //线性表存储空间的分配增量17 typedef struct {18 ElemType *elem; //存储空间基地址19int length; //当前长度20int listsize; //当前分配的存储容量21 } SqList;2223 Status InitList_Sq(SqList &L) { //算法2.324 L.elem = (ElemType *)malloc(LIST_INIT_SIZE * sizeof(ElemType));25if (!L.elem) exit(OVERFLOW); //存储分配失败26 L.length = 0; //空表长度为027 L.listsize = LIST_INIT_SIZE; //初始存储容量28return OK;29 }//InitList_Sq3031 Status ListInsert_Sq(SqList &L, int i, ElemType e) { //算法2.432 ElemType *newbase, *p, *q;33if (i<1 || i>L.length + 1) return ERROR; //i值不合法34if (L.length >= L.listsize)35 { //当前存储空间已满,增加分配36 newbase = (ElemType*)realloc(L.elem, (L.listsize + LISTINCREMENT) * sizeof(ElemType));37if (!newbase) exit(OVERFLOW); //存储分配失败38 L.elem = newbase; //新基址39 L.listsize += LISTINCREMENT; //增加存储容量40 }41 q = &(L.elem[i - 1]); //q为插⼊位置42for (p = &(L.elem[L.length - 1]); p >= q; --p) *(p + 1) = *p; //元素右移43 *q = e; //插⼊e44 ++L.length; //表长增145return OK;46 }4748void DispSqList(SqList L)49 {50int i;51for (i = 0; i < L.length; i++)52 printf("%c ", L.elem[i]);53 }5455 Status ListDelete(SqList &L, int i, ElemType &e)56 {57 ElemType *p,*q;58if ((i < 1) || (i > L.length)) return ERROR;59 p = &(L.elem[i - 1]);60 e = *p;61 q = L.elem + L.length - 1;62for (++p; p <= q; ++p)63 *(p - 1) = *p;64 --L.length;65return OK;66 } //ListDelete_Sq6768 Status GetElem(SqList L, int i, ElemType &e)69 {70if (L.length == 0 || i<1 || i>L.length)71return ERROR;72 e = L.elem[i - 1];73return OK;74 }7576int ListLength(SqList L)77 {78return(L.length);79 }8081 Status DestroyList(SqList &L)82 {83 free(L.elem);84 L.length = 0;85return OK;86 }8788 Status ListEmpty(SqList L)89 {90return(L.length == 0);91 }9293int LocateElem(SqList L, ElemType e)94 {95int i = 0;96while (i < L.length && L.elem[i] != e) i++;97if (i >= L.length) return0;98else return i + 1;99 }100101void main()102 {103 SqList h;104 ElemType e;105 InitList_Sq(h);106 ListInsert_Sq(h, h.length + 1, 'a');107 ListInsert_Sq(h, h.length + 1, 'b');108 ListInsert_Sq(h, h.length + 1, 'c');109 ListInsert_Sq(h, h.length + 1, 'd');110 ListInsert_Sq(h, h.length + 1, 'e');111 DispSqList(h);112 printf("%d\n\n",ListLength(h));113 ListEmpty(h);114if (ListEmpty(h))116 printf("Empty\n\n");117 }118else119 {120 printf("Not empty\n\n");121 }122 GetElem(h, 4, e);123 printf("%c\n", e);124 printf("%d\n",LocateElem(h, 'c'));125 ListInsert_Sq(h,3,' f');126 DispSqList(h);127 ListDelete(h, 2, e);128 DispSqList(h);129 DestroyList(h);130 }131132133134135136单链表137138139140 #include<stdio.h>141 #include<malloc.h>142 #include<stdlib.h>143144#define TRUE 1145#define FALSE 0146#define OK 1147#define ERROR 0148#define INFEASIBLE -1149#define OVERFLOW -2150 typedef int Status;151152 typedef char ElemType;153154155 typedef struct LNode {156 ElemType data;157int length;158struct LNode *next;159 }LNode, *LinkList;160161162 Status InitList_L(LinkList &L) {163 L = (LinkList)malloc(sizeof(LNode));164 L->next = NULL;165return OK;166 }167168 Status ListInsert_L(LinkList L, int i, ElemType e) { 169 LinkList p = L,s;170int j = 0;171while (p && j < i - 1)172 {173 p = p->next;174 ++j;175 }176if (!p || j > i - 1)177 {178return ERROR;179 }180else181 {182 s = (LinkList)malloc(sizeof(LNode));183 s->data = e;184 s->next = p->next;185 p->next = s;186return OK;187 }188 }189190void DispList_L(LinkList L)191 {192 LinkList p = L->next;193while (p != NULL)194 {195 printf("%c\n", p->data);196 p = p->next;197 }198200201void DestoryList(LinkList &L)202 {203 LinkList p = L, q = p->next;204while (q != NULL)205 {206 free(p);207 p = q;208 q = p->next;209 }210 free(p);211 }212213 Status ListLength_L(LinkList L) {214 LinkList p = L; int n = 0;215while (p->next != NULL)216 {217 n++;218 p = p->next;219 }220return (n);221 }222223 Status ListDelete(LinkList L, int i, ElemType &e){ 224int j;225 LinkList p, q;226 p = L;227 j = 1;228while (p->next && j < i)229 {230 p = p->next;231 ++j;232 }233if (!(p->next) || j > i)234 {235return ERROR;236 }237 q = p->next;238 p->next = q->next;239 e = q->data;240 free(q);241return OK;242 }243244 Status ListEmpty_L(LinkList L)245 {246return(L->length == 0);247 }248249 Status GetElem(LinkList L, int i, ElemType &e) 250 {251int j;252 LinkList p;253 p = L->next;254 j = 1;255while (p&&j<i)256 {257 p = p->next;258 ++j;259 }260if (!p || j > i)261 {262return ERROR;263 }264 e = p->data;265return OK;266 }267268 Status LocateElem(LinkList L, int e)269 {270 LinkList p = L;271int n=0;272//p->length = 0;273while (p != NULL)274 {275if(p->data != e)276 {277 p = p->next;278 n++;279 }280else281 {282break;283 }284 }285if(p != NULL)286 {287return n;288 }289else290 {291return ERROR;292 }293 }294295void main()296 {297 LinkList h;298 ElemType e;299 InitList_L(h);300 ListInsert_L(h, 1, 'a');301 ListInsert_L(h, 2, 'b');302 ListInsert_L(h, 3, 'c');303 ListInsert_L(h, 4, 'd');304 ListInsert_L(h, 5, 'e');305 DispList_L(h);306 printf("%d\n", ListLength_L(h)); 307if (ListEmpty_L(h))308 {309 printf("Empty\n\n");310 }311else312 {313 printf("Not empty\n\n");314 }315 GetElem(h, 4, e);316 printf("%c\n", e);317 printf("%d\n", LocateElem(h, 'c')); 318 ListInsert_L(h, 3, 'f');319 DispList_L(h);320 ListDelete(h, 2, e);321 DispList_L(h);322 DestoryList(h);323 }。
第三章 链表
第三章 链表
第三章 链表
知识点
单链表的结点形式、组织方法和特点 单链表的基本运算和相应的算法 循环链表的组织方法和基本运算算法 双链表的结点形式、组织方法和特点 双链表的基本运算和相应的算法 顺序表与链表比较,各自的优、缺点 链表的应用 用十字链表表示稀疏矩阵
第三章 链表
难点
双链表插入、删除运算的算法 利用链接结构的特点设计有效算法,解决与链表结 构相关的应用问题
第三章 链表
算法分析
此算法的关键是while循环语句,开始时p 指针指向头结点,每一循环都修改指针 值,让它指向下一个结点,同时将计数 链表长度的变量count加1。 这样每循环一次就向后推移一个结点, 直到p所指结点*p的链域值为NULL为止。 空指针NULL起标志的作用,若无此标志, 尾结点链域的值为“无定义”,上述算 法中的while语句在做最后一次判断时将 出现“运行错”,这是应予避免的。
第三章 链表
3.3.2 链队列
链队列需要两个指针,其中队首指针front指向 链表的表头,队尾指针rear指向链表的表尾。 一般插入时只修改队尾结点的指针和队尾指针 rear,删除时只修改队首指针front。当将第一个 元素插入空队列或删除了最后一个元素而使队 列为空时,front和rear都需要修改。 front rear
当需要从单链表上删除结点时,就要通过删 除运算来完成。 删除单链表上一个其值为x的结点的主要操作 是:
1) 用遍历的方法在单链表上找到该结点; 2) 从单链表上删除该结点。
欲从单链表上删除一个结点,需修改该结点 的前一个结点的指针,如下面的图所示。
第三章 链表
q head
p x ∧
假设指针q指向待删除结点的前一个结点,指 针p指向要删除的结点,删除该结点的操作如 下:将该结点的前一个结点*q的链域指向*p 的后继结点(即q->next=p->next)。
链表实验报告总结
链表实验报告总结链表实验报告总结篇一:顺序表,链表总结实验报告实验报告实验目的:学生管理系统(顺序表)实验要求:1.建表2.求表长3.插入4.查找5.删除6.列表7.退出源程序:#include#include#include#define MaxSize 1000typedef struct{char xh[40];char xm[40];int cj;}DataType; //学生的结构typedef struct {DataType data[MaxSize]; //定义表的数据类型int length; //数据元素分别放置在data[0]到data[length-1]当中} SqList; //表的结构void liebiao(SqList *L)//{int k,n;char q;printf("请输入,输入学生的个数:\n"); fflush(stdin);scanf("%d",&n);for(k=0;k {printf("请输入学生学号\n");scanf("%s",L->data[k].xh);printf("请输入学生名字\n");scanf("%s",L->data[k].xm);printf("请输入学生成绩\n");scanf("%d",&L->data[k].cj); 建立表格}。
数据结构简答题打印版
数据结构简答题打印版数据结构简答题1.1 简述下列术语:数据,数据元素、数据对象、数据结构、存储结构、数据类型和抽象数据类型。
解:数据是对客观事物的符号表⽰。
在计算机科学中是指所有能输⼊到计算机中并被计算机程序处理的符号的总称。
数据元素是数据的基本单位,在计算机程序常作为⼀个整体进⾏考虑和处理。
数据对象是性质相同的数据元素的集合,是数据的⼀个⼦集。
数据结构是相互之间存在⼀种或多种特定关系的数据元素的集合。
存储结构是数据结构在计算机中的表⽰。
数据类型是⼀个值的集合和定义在这个值集上的⼀组操作的总称。
抽象数据类型是指⼀个数学模型以及定义在该模型上的⼀组操作。
是对⼀般数据类型的扩展。
1.2 试描述数据结构和抽象数据类型的概念与程序设计语⾔中数据类型概念的区别。
解:抽象数据类型包含⼀般数据类型的概念,但含义⽐⼀般数据类型更⼴、更抽象。
⼀般数据类型由具体语⾔系统部定义,直接提供给编程者定义⽤户数据,因此称它们为预定义数据类型。
抽象数据类型通常由编程者定义,包括定义它所使⽤的数据和在这些数据上所进⾏的操作。
在定义抽象数据类型中的数据部分和操作部分时,要求只定义到数据的逻辑结构和操作说明,不考虑数据的存储结构和操作的具体实现,这样抽象层次更⾼,更能为其他⽤户提供良好的使⽤接⼝。
1.7 在程序设计中,可采⽤下列三种⽅法实现输出和输⼊:(1) 通过scanf和printf语句;(2) 通过函数的参数显式传递;(3) 通过全局变量隐式传递。
试讨论这三种⽅法的优缺点。
解:(1)⽤scanf和printf直接进⾏输⼊输出的好处是形象、直观,但缺点是需要对其进⾏格式控制,较为烦琐,如果出现错误,则会引起整个系统的崩溃。
(2)通过函数的参数传递进⾏输⼊输出,便于实现信息的隐蔽,减少出错的可能。
(3)通过全局变量的隐式传递进⾏输⼊输出最为⽅便,只需修改变量的值即可,但过多的全局变量使程序的维护较为困难。
2.1 描述以下三个概念的区别:头指针,头结点,⾸元结点(第⼀个元素结点)。
顺序表类型的定义
顺序表类型的定义在计算机编程中,顺序表类型是一种最基本的数据结构,是指在内存中一组元素构成的线性表,其中元素用逻辑上的顺序表示,并且随机访问这些元素是可以实现的。
它是一种以物理位置相关的表示,可以保存任何类型的数据,比如整数、浮点数和字符串等。
在顺序表中,元素的添加和删除通常由表的开始位置和尾部位置来控制,并且顺序表本身不可以大小变化。
顺序表的主要特点是可以快速的查找数据,无需额外的存储空间,并且插入和删除数据也只需要访问少量的位置。
但是,由于顺序表只能在一定范围内进行插入和删除操作,因此当数据较大时,操作将会变得非常复杂。
顺序表的实现可以使用一维数组和二维数组两种方式。
在一维数组中,用一维数组来存储数据,并且记录数组中有效元素的数量,从而完成各种操作。
二维数组是将空间地址均匀分配到每个元素,将一维数组中的元素通过二维数组来实现。
顺序表的应用非常广泛,它的各种操作比较简单,可以快速的在顺序表中查找需要的数据。
因此,顺序表在计算机程序中被广泛应用,可以说它是计算机科学的一个重要的基础,也是实现数据结构的基础。
顺序表的实现不仅可以使用一维数组和二维数组,还可以使用链表来实现。
链表是一种物理结构,它使用一系列节点来存储数据,每个节点都有指针指向其他节点,并且可以实现快速的插入和删除操作。
此外,由于链表的结构特性,链表在插入和删除操作时不会浪费更多的内存空间,也可以避免内存碎片的产生,所以它也是实现顺序表的一种重要方式。
总之,顺序表是计算机编程中一种常用的数据结构,它可以使用一维数组、二维数组和链表来实现,其主要特点是可以快速查找数据,而且插入和删除数据也只需要访问少量的位置。
顺序表可以用于实现多种数据结构,因此在计算机科学中它是一个重要的基础,也是实现复杂数据结构的基础。
顺序表、链表数据结构的特点
顺序表、链表数据结构的特点
顺序表和链表是常见的数据结构,它们在实现和应用上有各自的特点。
1. 顺序表:
顺序表是一种基于数组实现的连续存储的线性结构。
其特点是支持随机访问,即可以通过下标直接访问任意位置的元素;同时插入或删除元素时需要移动其他元素,效率较低。
适合于元素数量固定,频繁访问但不频繁插入或删除的场景。
2. 链表:
链表是一种非连续存储的线性结构,每个元素(节点)包含数据和指向下一个节点的指针。
其特点是支持快速插入和删除元素,但访问某个元素需要遍历整个链表,效率较低。
适合于元素数量不固定,频繁插入或删除但不频繁访问的场景。
综上所述,顺序表和链表各有其适用场景。
在实际应用中,需要根据具体情况选择合适的数据结构来实现需求。
- 1 -。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
设计一顺序表的应用代码Head.h#define LIST_INIT_SIZE 100//线性表存储空间的初始分配量#define LISTINCREMENT 10//线性表存储空间的分配增量#define STACK_INIT_SIZE 100//栈存储空间初始分配量#define STACKINCREMENT 10//栈存储空间分配增量#define MAXQSIZE 10//最大队列长度typedef int ElemType;typedef char SElemType;typedef int QElemType;typedef struct{int *elem;//存储空间基址int length;//当前长度int listsize;//当前分配的存储容量}SqList;typedef struct{SElemType *base;//在栈构造之前和销毁之后,base的值为null SElemType *top;//栈顶指针int stacksize;//当前已分配的存储空间,以元素为单位}SqStack;typedef struct{QElemType *base;//初始化的动态分配存储空间int front;//头指针,若队列不空,指向队列头元素int rear;//尾指针,若队列不空,指向队列尾元素的下一个位置}SqQueue;void Check1();void Check2();void Check3();void Check4();int InitList_Sq(SqList *L);int CreateList(SqList *L);int DeleteElem_Sq(SqList *L);int PrintElem(SqList L);int DeleteElem_1(SqList *L);int DevideList_Sq(SqList L,SqList *La,SqList *Lb);int InitStack(SqStack *L);int Push(SqStack *S,SElemType e);int StackEmpty(SqStack S);int GetTop(SqStack S,SElemType *e);int Pop(SqStack *S,SElemType *e);int Correct(char exp[], int n);int InitQueue(SqQueue *Q);int CreateQueue(SqQueue *Q);int PrintQueue(SqQueue Q);int EnQueue(SqQueue *Q,QElemType e);int DeQueue(SqQueue *Q,QElemType *e); ………………………………………………………………………………………………………. main.cpp#include<stdio.h>#include "head.h"#include"stdlib.h"#include <string.h>void main(){int choice;do{printf("\n 顺序表的应用\n");printf("\n ------------主菜单-------------- \n");printf(" (1) 删除线性表中值为item的元素\n");printf(" (2) 将一个顺序表分拆成两个顺序表 \n");printf(" (3) 判断括弧是否匹对 \n");printf(" (4) 循环队列中插入和取出节点\n");printf(" (0) 退出系统 \n");printf("\n请选择操作步骤:");scanf("%d",&choice);if(choice<0 && choice>4) continue;switch(choice){case 1:Check1();break;case 2:Check2();break;case 3:Check3();break;case 4:Check4();break;case 0:exit(0);default:break;}}while(1);} ………………………………………………………………………………………………………. Check1.cpp#include "head.h"#include <stdio.h>void Check1(){SqList L1;printf("实现删除线性表中值为item的元素的算法:\n");CreateList(&L1);//实现第一个算法PrintElem(L1);DeleteElem_1(&L1);PrintElem(L1);}CreateList.cpp#include"head.h"#include"stdio.h"#include"stdlib.h"//创建顺序表,在顺序表中输入数据元素。
int CreateList(SqList *L){int i,n;if(!InitList_Sq(L))exit(-1);printf("请输入顺序表的长度:");scanf("%d",&n);(*L).length=n;ElemType *p=(*L).elem;printf("请输入顺序表的数据元素:");for(i=0;i<n;i++){scanf("%d",p);p++;}return 1;}PrintElem.cpp#include "head.h"#include <stdio.h>int PrintElem(SqList L){if(L.length==0)printf("Empty!\n");int i;for(i=0;i<L.length;i++)printf("%4d",L.elem[i]);printf("\n");return 1;}DeleteElem_1.cpp#include "head.h"#include<stdio.h>int DeleteElem_1(SqList *L){int *p,*q,item;printf("请输入要删去的元素:");scanf("%d",&item);p=(*L).elem;q=(*L).elem+(*L).length-1;while(p<q){if(*p==item){*p=*q;q--;(*L).length--;}else p++;}if(*p==item)(*L).length--;return 1;}………………………………………………………………………………………………………. Check2().cpp#include "head.h"#include <stdio.h>void Check2(){SqList L2,La,Lb;printf("实现将一个顺序表分拆成两个顺序表的算法:\n");CreateList(&L2);//实现第二个算法PrintElem(L2);DevideList_Sq(L2,&La,&Lb);PrintElem(La);PrintElem(Lb);}DevideList_Sq.cpp#include "head.h"int DevideList_Sq(SqList L,SqList *La,SqList *Lb){InitList_Sq(La);InitList_Sq(Lb);(*La).length=(*La).length=0;int *p,*q;p=L.elem;q=L.elem+L.length-1;for(;p<=q;p++){if((*p)>0)(*La).elem[(*La).length++]=*p;else (*Lb).elem[(*Lb).length++]=*p;}return 1;}InitList_Sq.cpp#include "head.h"#include <stdlib.h>//构造一个空的线性表int InitList_Sq(SqList *L){(*L).elem=(ElemType *)malloc(LIST_INIT_SIZE*sizeof(ElemType));if(!((*L).elem))exit(-1);//存储分配失败(*L).length=0;//空表长度为0(*L).listsize=LIST_INIT_SIZE;//初始存储容量return 1;}………………………………………………………………………………………………………. Check3().cpp#include "head.h"#include <stdio.h>#include<string.h>void Check3(){printf("实现判断括弧是否匹对的算法:\n");char a[20];//实现第三个算法int tag;printf("Input String:");scanf("%s",a);tag=Correct(a,strlen(a));if(tag) printf("correct!\n");else printf("wrong!\n");}Correct.cpp#include "head.h"int Correct(char exp[], int n){SqStack S; InitStack(&S);char *p=exp,e,x;int i;for(i=0;i<n;i++,p++){if(*p=='('||*p=='['||*p=='{')Push(&S,*p);else if(*p==')'||*p==']'||*p=='}'){GetTop(S,&e);switch(*p){case ')':if(e=='(')Pop(&S,&x);else return 0;break;case ']':if(e=='[')Pop(&S,&x);else return 0;break;case '}':if(e=='{')Pop(&S,&x);else return 0;break;}}}if(!StackEmpty(S))return 0;else return 1;}GetTop.cpp#include "head.h"int GetTop(SqStack S,SElemType *e){//若栈不空,则用e返回S的栈顶元素,并返回1,否则返回0 if(S.top==S.base)return 0;else *e=*(S.top-1);return 1;}InitStack.cpp#include<stdlib.h>#include "head.h"//构造一个空栈int InitStack(SqStack *S){(*S).base=(SElemType *)malloc(STACK_INIT_SIZE*sizeof(SElemType));if(!(*S).base)exit(-1);//存储分配失败(*S).top=(*S).base;(*S).stacksize=STACK_INIT_SIZE;return 1;}Pop.cpp#include "head.h"int Pop(SqStack *S,SElemType *e){//若栈不空,则删除S的栈顶元素,用e返回其值,并返回1,否则返回0 if(StackEmpty(*S))return 0;*e=*(--(*S).top);return 1;}Push.cpp#include<stdlib.h>#include "head.h"int Push(SqStack *S,SElemType e){//插入元素e为新的栈顶元素if((*S).top-(*S).base>=(*S).stacksize)//栈满,追加存储空间{(*S).base=(SElemType*)realloc((*S).base,((*S).stacksize+STACKINCREMENT)*sizeof(SElemType));if(!(*S).base)exit(-1);//存储分配失败(*S).stacksize+=STACKINCREMENT;}*((*S).top++)=e;return 1;}StackEmpty.cpp#include "head.h"int StackEmpty(SqStack S){if(S.top==S.base)return 1;else return 0;}………………………………………………………………………………………………………. Check4().cpp#include "head.h"#include <stdio.h>void Check4(){printf("实现循环队列中插入和取出节点的算法:\n");SqQueue Q;//实现第四个算法QElemType e;CreateQueue(&Q);printf("请输入插入的节点:");scanf("%d",&e);PrintQueue(Q);EnQueue(&Q,e);PrintQueue(Q);DeQueue(&Q,&e);PrintQueue(Q);}CreateQueue.cpp#include<stdio.h>#include "head.h"//创建一个队列int (SqQueue *Q){int n,i;InitQueue(Q);printf("输入队列的长度:");scanf("%d",&n);if(n>MAXQSIZE){printf("overflow!\n");return 0;}for(i=0;i<n-1;i++)scanf("%d",((*Q).base)+i);(*Q).rear=n-1;return 1;}DeQueue.cpp#include "head.h"#include<stdio.h>int DeQueue(SqQueue *Q,QElemType *e){//若队列不空,则删除Q的队头元素,用e返回其值,并返回1,否则返回0 if((*Q).front==(*Q).rear){printf("The Queue is empty!");return 0;}*e=(*Q).base[(*Q).front];(*Q).front=((*Q).front+1)%MAXQSIZE;return 1;}EnQueue.cpp#include<stdio.h>#include "head.h"int EnQueue(SqQueue *Q,QElemType e){//插入元素e为新的队尾元素if(((*Q).rear+1)%MAXQSIZE==(*Q).front){printf("overflow!\n");return 0;}//队列满((*Q).base)[(*Q).rear]=e;(*Q).rear=((*Q).rear+1)%MAXQSIZE;return 1;}InitQueue.cpp#include "head.h"#include <stdlib.h>//构造一个空队列int InitQueue(SqQueue *Q){(*Q).base=(QElemType *)malloc(MAXQSIZE*sizeof(QElemType));if(!((*Q).base))exit(-1);//存储空间分配失败(*Q).front=(*Q).rear=0;return 1;}PrintQueue.cpp#include "head.h"#include<stdio.h>int PrintQueue(SqQueue Q){if(Q.front==Q.rear){printf("empty!");return 0;}int i,n;QElemType *p;n=(Q.rear-Q.front+MAXQSIZE)%MAXQSIZE;p=&((Q.base))[Q.front];for(i=0;i<n;i++){printf("%4d",*p);if(p==&Q.base[MAXQSIZE-1])p=Q.base;else p++;}printf("\n");return 1;} ……………………………………………………………………………………………………….设计二链表的应用代码Head.htypedef int ElemType;typedef struct LNode{//线性表的单链表存储结构ElemType data;struct LNode *next;}LNode,*LinkList;typedef struct DuLNode{//线性表的双向链表存储结构ElemType data;struct DuLNode *prior;struct DuLNode *next;int freq;}DulNode,*DuLinkList;void CreateList_L(LinkList *L,int n);int PrintLinkList(LinkList L);int EqualLinkList(LinkList *La,LinkList *Lb);void CreatCircularLinkList(LinkList *L,int n);int MonkeyKing(LinkList L,int n);int LinkListLength_Dul(DuLinkList L);int CreateLinkList_Dul(DuLinkList *L,int n);int PrintLinkList_Dul(DuLinkList L);int Locate(DuLinkList *L,ElemType e);//int InterSection(LinkList La,LinkList Lb,LinkList *Lc);void Check_1();void Check_2();void Check_3();…………………………………………………………………………………………………….... main.cpp#include<stdio.h>#include "head.h"#include<stdlib.h>void main(){int choice;do{printf("\n 链表的应用\n");printf("\n ------------主菜单-------------- \n");printf(" (1) 删除两个递增链表中不同的元素 \n");printf(" (2) 猴子选大王\n");printf(" (3) 实现locate函数\n");printf(" (0) 退出系统... \n");printf("\n请选择操作步骤:");scanf("%d",&choice);if(choice<0 && choice>3) continue;switch(choice){case 1:Check_1();break;case 2:Check_2();break;case 3:Check_3();break;case 0:exit(0);default:break;}}while(1);} …………………………………………………………………………………………………….... Check_1.cpp#include "head.h"#include <stdio.h>void Check_1(){LinkList La,Lb;int n1,n2;printf("请输入单链表La的长度:");scanf("%d",&n1);printf("请按逆位序输入:\n");CreateList_L(&La,n1);printf("La:");PrintLinkList(La);printf("请输入单链表Lb的长度::");scanf("%d",&n2);printf("请按逆位序输入:\n");CreateList_L(&Lb,n2);printf("Lb:");PrintLinkList(Lb);EqualLinkList(&La,&Lb);printf("删除元素以后\n");printf("La:");PrintLinkList(La);printf("Lb:");PrintLinkList(Lb);}CreateList_L.cpp#include<stdio.h>#include "head.h"#include<stdlib.h>void CreateList_L(LinkList *L,int n){//逆位序输入n个元素的值,建立带表头结点的单性线性表L int i;LinkList p;*L=(LinkList)malloc(sizeof(LNode));(*L)->next=NULL;//先建立一个带头结点的单链表for(i=n;i>0;--i){p=(LinkList)malloc(sizeof(LNode));//生成新结点scanf("%d",&(p->data));//输入元素值p->next=(*L)->next;(*L)->next=p;//插入到表头}}EqualLinkList.cpp#include "head.h"#include<stdlib.h>int EqualLinkList(LinkList *La,LinkList *Lb){//删除两单链表中不同的元素LinkList ha,hb,pa,pb;ha=*La;hb=*Lb;pa=ha->next;pb=hb->next;while(pa&&pb){if(pa->data<pb->data){ha->next=pa->next;free(pa);pa=ha->next;}else if(pa->data>pb->data){hb->next=pb->next;free(pb);pb=hb->next;}else {ha=pa;pa=pa->next;hb=pb;pb=pb->next;}}if(pa){ha->next=NULL;free(pa);}else {hb->next=NULL;free(pb);}return 1;}PrintLinkList.cpp#include "head.h"#include<stdio.h>int PrintLinkList(LinkList L){//输出单链表LinkList p=L->next;if(!p)printf("Empty!\n");while(p){printf("%4d",p->data);p=p->next;}printf("\n");return 1;}…………………………………………………………………………………………………….... Check_2.cpp#include "head.h"#include<stdio.h>void Check_2(){int n;LinkList L;printf("请输入猴子的个数:");scanf("%d",&n);CreatCircularLinkList(&L,n);MonkeyKing(L,n);}MonkeyKing.cpp#include "head.h"#include <stdio.h>int MonkeyKing(LinkList L,int n){int m;printf("输入m:");scanf("%d",&m);LinkList p=L,p1=L;while(p1->next!=L)p1=p1->next;int k=n,i=0,j=0;while(i<n-1){j++;if(j==m){p1->next=p->next;j=0;i++;}else p1=p;p=p->next;}printf("%d is the King\n",p1->data);return 1;}CreatCircularLinkList.cpp#include "head.h"#include<stdlib.h>#include<stdio.h>void (LinkList *L,int n){//建一个不带头结点的循环链表,L为头指针int i;LinkList p;*L=(LinkList)malloc(sizeof(LNode));(*L)->next=*L;(*L)->data=1;//printf("input the number of elements of LNode:");//scanf("%d",&n);for(i=n;i>1;--i){p=(LinkList)malloc(sizeof(LNode));//scanf("%d",&(p->data));p->data=i;p->next=(*L)->next;(*L)->next=p;}} ……………………………………………………………………………………………………....#include<stdio.h>#include "head.h"void Check_3(){DuLinkList D;int e,i,choice;printf("请输入非循环双链表的元素的个数:");scanf("%d",&i);CreateLinkList_Dul(&D,i);printf("执行Locate运算前:\n");PrintLinkList_Dul(D);do{printf("请输入要访问元素的值:");scanf("%d",&e);Locate(&D,e);printf("执行Locate运算后:\n");PrintLinkList_Dul(D);printf("输入choice的值,输入1代表继续执行locate,输入0代表退出:\n");scanf("%d",&choice);}while(choice);printf("OK!\n");}Locate.cpp#include "head.h"#include<stdio.h>int Locate(DuLinkList *L,ElemType e){DuLinkList s,t,p=(*L)->next;if(!p) {printf("Error!");return 0;}int i=0,n=LinkListLength_Dul(*L);while(p!=NULL){if(p->data==e){i++;(p->freq)++;printf("频度为%d\n",p->freq);s=p;if(p->next==NULL)p->prior->next=NULL;elsep->next->prior=p->prior;p->prior->next=p->next;}//p=s->next;t=s->prior;while(((t->freq)<(s->freq))&&t!=(*L))t=t->prior;if((t->freq)>=(s->freq)){s->next=t->next;t->next->prior=s;s->prior=t;t->next=s;}else{s->next=(*L)->next;(*L)->next->prior=s;s->prior=(*L);(*L)->next=s;}}p=p->next;}if(i==0){printf("Not found!\n");return 0;}return 1;}CreateLinkList_Dul.cpp#include "head.h"#include<stdlib.h>#include<stdio.h>int (DuLinkList *L,int n){DuLinkList p1,p2;int i;*L=(DuLinkList)malloc(sizeof(DuLNode));(*L)->prior=NULL;(*L)->next=NULL;//(*L)->freq=0;p1=*L;printf("输入元素:\n");for(i=1;i<=n;i++){p2=(DuLinkList)malloc(sizeof(DuLNode));scanf("%d",&(p2->data));p1->next=p2;p2->prior=p1;p2->freq=0;p1=p2;}p2->next=NULL;return 1;}LinkListLength_Dul.cpp#include "head.h"int LinkListLength_Dul(DuLinkList L){DuLinkList p=L->next;int i=0;while(p){i++;p=p->next;}return i;}PrintLinkList_Dul.cpp#include "head.h"#include <stdio.h>int PrintLinkList_Dul(DuLinkList L){DuLinkList p=L->next;if(!p){printf("Empty!");return 0;}while(p){printf("%4d",p->data);p=p->next;}printf("\n");return 1;} ……………………………………………………………………………………………………....。