《数据结构》顺序表、链表的操作

合集下载

数据结构中顺序表与链表的性能方面比较

数据结构中顺序表与链表的性能方面比较

数据结构中顺序表与链表的性能⽅⾯⽐较
⼀,时间性能的⽐较
顺序表由数组实现,是⼀种随机存取结构,对表中任意节点存取操作时间复杂度为O(1)。

⽽查找链表的节点,须从头指针开始沿链扫描,平均时间复杂度为O(N).因此,若线性表的操作主要是查找,很少进⾏插⼊或删除操作,采⽤顺序⽐较合适。

对于链表,对某个节点进⾏插⼊删除操作只需修改指针,⽆需⼤量移动元素,平均时间复杂度为O(1)。

⽽顺序表在插⼊或删除时,需要⼤量移动数据元素,平均移动元素的数⽬为表长的⼀般,时间复杂度为O(N)。

因此,对线性表频繁的进⾏插⼊删除操作时,应采⽤链表。

当插⼊和删除主要在表头或表尾时,应采⽤循环链表。

表1:时间性能⽐较
时间复杂度查找插⼊或删

顺序表O(1)O(N)
链表O(N)O(1)
⼆,空间性能的⽐较
1,顺序表的存储空间是静态分配的,必须提前确定其内存⼤⼩。

常⽤于存储规模容易确定的线性表。

2,动态链表的存储空间是动态分配的,只要其内存空间有空闲就不会出现溢出。

常⽤于长度变化较⼤或长度难以估计的线性表。

3,定义:存储密度=(节点中数据域占⽤的空间)/(节点结构占⽤的存储空间)
有时需考虑存储密度。

综上,在选取线性表时,应综合考虑时间和空间因素,选择⼀中最适合的。

⼀般⽽⾔,顺序表适⽤于查询,⽽链表则更便于插⼊删除管理。

《数据结构》实验指导书

《数据结构》实验指导书
四、实验说明
1.单链表的类型定义
#include <stdio.h>
typedef int ElemType;//单链表结点类型
typedef struct LNode
{ElemType data;
struct LNode *next;
2.明确栈、队列均是特殊的线性表。
3.栈、队列的算法是后续实验的基础(广义表、树、图、查找、排序等)。
六、实验报告
根据实验情况和结果撰写并递交实验报告。
实验四 串
一、预备知识
1.字符串的基本概念
2.字符串的模式匹配算法
二、实验目的
1.理解字符串的模式匹配算法(包括KMP算法)
typedef struct
{ElemType *base;
int front,rear;
} SqQueue;
4.单链队列的类型定义
typedef struct QNode
{QElemType data;
typedef struct list
{ElemType elem[MAXSIZE];//静态线性表
int length; //顺序表的实际长度
} SqList;//顺序表的类型名
五、注意问题
1.插入、删除时元素的移动原因、方向及先后顺序。
4.三元组表是线性表的一种应用,通过它可以更好地理解线性表的存储结构。同时矩阵又是图的重要的存储方式,所以这个实验对更好地掌握线性表对将来对图的理解都有极大的帮助。
六、实验报告
根据实验情况和结果撰写并递交实验报告。
实验六 树和二叉树
一、预备知识
1.二叉树的二叉链表存储结构

chap2数据结构,顺序表,树,图,链表,排序

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.集合中必存在唯一的一个 “最后元素”

《数据结构》考试大纲 专升本

《数据结构》考试大纲 专升本

《数据结构》考试大纲(专升本)一、考试性质《数据结构》是计算机科学与技术专业的核心课程,是计算机专业专升本入学考试的必考科目之一。

数据结构是计算机程序设计的重要理论基础,主要研究数据的各种内在规律和特性,以及如何在计算机中实现和应用这些规律和特性。

通过对数据结构的学习,可以使考生掌握数据的组织、存储和处理的基本方法,培养考生运用所学知识解决实际问题的能力。

二、考试目标本考试的目的是测试考生对数据结构基本概念、基本原理和基本方法的掌握程度和应用能力。

具体来说,考试应达到以下目标:1. 掌握数据结构的基本概念、基本原理和基本方法,包括数据的逻辑结构、存储结构和算法等。

2. 掌握线性表、栈、队列、树、图等基本数据结构的定义、表示和操作,理解它们的特性和应用场景。

3. 掌握常见的数据结构算法,包括查找、排序、图论算法等,能够分析和评估算法的时间复杂度和空间复杂度。

4. 了解数据结构的实际应用,如动态内存分配、数据压缩、文件存储管理等。

三、考试内容1. 数据结构的基本概念:数据的逻辑结构、存储结构、算法的描述与实现等。

2. 线性表:顺序表和链表的定义、表示和操作,包括插入、删除、查找等操作的时间复杂度分析。

3. 栈:栈的定义、表示和操作,包括入栈、出栈、判断栈是否为空等操作的时间复杂度分析。

4. 队列:队列的定义、表示和操作,包括入队、出队、判断队列是否为空等操作的时间复杂度分析。

5. 树:树的基本概念,包括树、森林、二叉树等;二叉树的定义、表示和操作,包括插入、删除节点等操作的时间复杂度分析;二叉搜索树、平衡二叉树等数据结构的定义和操作。

6. 图:图的基本概念,包括无向图、有向图等;图的表示方法,包括邻接矩阵和邻接表等;图的遍历算法,包括深度优先搜索和广度优先搜索等;最小生成树的概念和构造方法(Prim算法和Kruskal算法);最短路径算法(Dijkstra算法和Floyd-Warshall算法)等。

数据结构-顺序表

数据结构-顺序表

数据结构-顺序表判断题1.(neuDS)所谓随机存取,就是通过⾸地址和元素的位序号值可以在O(1)的时间内找到指定的元素。

F2.(neuDS)在顺序表上进⾏插⼊、删除操作时需要移动元素的个数与待插⼊或待删除元素的位置⽆关。

T F3.顺序存储⽅式只能⽤于存储线性结构。

T F4.在顺序表中取出第i个元素所花费的时间与i成正⽐。

T F5.对于顺序存储的长度为N的线性表,删除第⼀个元素和插⼊最后⼀个元素的时间复杂度分别对应为O(1)和O(N)。

T F6.(neuDS)在顺序表中逻辑上相邻的元素,其对应的物理位置也是相邻的。

F7.顺序存储的线性表可以随机存取。

F8.顺序存储结构的主要缺点是不利于插⼊或删除操作。

F选择题1.⽤数组表⽰线性表的优点是()。

A.便于插⼊和删除操作B.便于随机存取C.可以动态地分配存储空间D.不需要占⽤⼀⽚相邻的存储空间2.阅读下列程序,其功能是()。

typedef struct {ElemType *list;int size;intMaxSize;}SeqList;void fun1(SeqList&L) {inti, j;ElemType temp;for (i=0, j= L.sise-1; i<j; i++, j--) {temp=L.list[i];L.list[i]=L.list[j];L.list[j]=temp;}}A.将顺序表原地逆置B.将链表原地逆置C.将顺序表⾸尾元素对换D.将链表⾸尾元素对换3.顺序存储表⽰中数据元素之间的逻辑关系是由()表⽰的。

A.指针B.逻辑顺序C.存储位置D.问题上下⽂4.顺序表的优点是()。

A.插⼊操作的时间效率⾼B.适⽤于各种逻辑结构的存储表⽰C.存储密度(存储利⽤率)⾼D.删除操作的时间效率⾼5.若线性表最常⽤的操作是存取第i个元素及其前驱的值,则采⽤( )存储⽅式节省时间。

A.单链表B.双向链表C.单循环链表D.顺序表6.数组A[1..5,1..6]每个元素占5个单元,将其按⾏优先次序存储在起始地址为1000的连续的内存单元中,则元素A[5,5]的地址为:A.1120B.1125C.1140D.11457.若某线性表最常⽤的操作是存取任⼀指定序号的元素和在最后进⾏插⼊和删除运算,则利⽤哪种存储⽅式最节省时间?A.双链表B.单循环链表C.带头结点的双循环链表D.顺序表8.若长度为n的线性表采⽤顺序结构,在第i个数据元素之前插⼊⼀个元素,需要它依次向后移动()个元素。

《数据结构》实验指导

《数据结构》实验指导

《数据结构》实验指导《数据结构》C语言版实验指导目录《数据结构》上机实验的目的和要求 (1)实验一顺序结构线性表的实现 (3)实验二单链表的插入和删除 (16)实验三栈的实现 (24)实验四二叉树操作实现 (30)实验五哈夫曼树的建立与编码实现 (39)实验六图的遍历操作 (50)实验七排序 (67)实验八查找 (83)《数据结构》课程设计 (95)《数据结构》上机实验的目的和要求通过上机实验加深对课程内容的理解,增加感性认识,提高软件设计、编写及调试程序的能力。

要求所编的程序能正确运行,并提交实验报告。

实验报告的基本要求为:1、需求分析:陈述程序设计的任务,强调程序要做什么,明确规定:(1)输入的形式和输出值的范围;(2)输出的形式;(3)程序所能达到的功能;(4)测试数据:包括正确的输入输出结果和错误的输入及输出结果。

2、概要设计:说明用到的数据结构定义、主程序的流程及各程序模块之间的调用关系。

3、详细设计:提交带注释的源程序或者用伪代码写出每个操作所涉及的算法。

4、调试分析:(1)调试过程中所遇到的问题及解决方法;(2)算法的时空分析;(3)经验与体会。

5、用户使用说明:说明如何使用你的程序,详细列出每一步操作步骤。

6、测试结果:列出对于给定的输入所产生的输出结果。

若有可能,测试随输入规模的增长所用算法的实际运行时间的变化。

实验一顺序结构线性表的实现一、目的:掌握顺序表的表示方法,存储结构及其基本操作的实现。

二、要求:建立一顺序表,实现其基本操作。

三、示例程序:说明:一个完整的程序是由输入,处理,输出三部分组成的,每个部分还可以分为若干小部分,如输入,又可以分为声明,初始化变量,接收数据,预处理数据等。

书上列出的算法是解决问题的基本思路,也可以是解决问题的处理过程,并未给出详细的输入与输出,这一部分需要在练习过程中加入,在解决实际问题时,还需要做灵活的处理。

C语言本身有自身的特点,其基本思想是与机器的指令码相关的。

《数据结构》教案

《数据结构》教案

《数据结构》教案教案1. 引言数据结构是计算机科学中一门重要的基础课程,它研究了组织和存储数据的方法以及处理数据的算法。

本教案旨在介绍数据结构的基本概念和常用的数据结构类型,帮助学生建立起正确的数据结构思维模式,培养数据分析和问题解决的能力。

2. 教学目标本教案的教学目标包括:- 理解数据结构的概念和重要性;- 掌握常见数据结构的定义和特点;- 熟悉数据结构的基本操作和算法;- 能够根据实际问题选择合适的数据结构并应用相应算法解决问题。

3. 教学内容3.1 数据结构的定义和概念- 数据结构的定义:数据结构是指数据对象及其之间的关系、操作和约束的集合。

- 数据结构的概念:包括逻辑结构、存储结构和运算结构。

3.2 线性表- 线性表的定义与特点- 顺序表的实现与操作- 链表的实现与操作- 栈和队列的定义与应用3.3 树与图- 树的定义与应用- 二叉树的实现与操作- 图的定义与存储方式- 图的遍历算法3.4 查找与排序- 查找算法:顺序查找、二分查找、哈希查找- 排序算法:冒泡排序、插入排序、选择排序、快速排序、归并排序3.5 高级数据结构- 堆和优先队列的概念与实现- 并查集的应用- 哈夫曼树的构建与压缩- 理论讲解与实践结合:通过理论讲解和实例演示相结合的方式,帮助学生理解数据结构的概念和应用。

- 实验操作与问题解决:通过实验操作和问题解决的方式,提升学生的数据结构应用能力和解决实际问题的能力。

- 小组合作与讨论:通过小组合作和讨论的方式,激发学生的学习兴趣,培养团队合作和沟通能力。

5. 教学评估本教案的教学评估方式包括:- 课堂测验:通过课堂测验检验学生对数据结构基本概念和常用算法的掌握情况。

- 实验报告:要求学生完成一定数量的实验,并提交实验报告,评估学生的实践能力和问题解决能力。

- 期末考试:在课程结束后,进行一次全面的期末考试,考察学生对整个课程内容的掌握情况。

6. 教学资源- 教材:《数据结构与算法分析》- 实验室设备:计算机、编程软件- 网络资源:数据结构相关的在线教学资源和学习资料授课时间:10周(每周2课时)7.1 第一周:数据结构基础概念和线性表7.2 第二周:线性表(续)和树7.3 第三周:树(续)和图7.4 第四周:查找与排序算法7.5 第五周:查找与排序算法(续)7.6 第六周:高级数据结构(堆与优先队列)7.7 第七周:高级数据结构(并查集)7.8 第八周:高级数据结构(哈夫曼树)7.9 第九周:教学复习与测验7.10 第十周:期末考试8. 教学反馈与改进本课程结束后,将进行学生教学反馈调查和课程改进总结,根据学生的意见和建议,不断完善教学内容和方法,提高教学质量和效果。

《数据结构》课程标准

《数据结构》课程标准

《数据结构》课程标准课程名称:数据结构课程代码:3250619适用专业:软件技术专业(软件开发方向)课程性质:专业必修课学时:48学时(理论:24 实践: 24)学分:3学分一、课程概述(一)课程的地位和作用《数据结构》是软件技术专业(软件开发方向)的一门专业必修课。

课程的前导课程是《Java面向对象编程》,本课程在后续软件开发类课程中起着非常重要的作用,其知识的应用将贯穿于本专业的所有课程。

在程序设计中,一个好的程序无非是选择一个合适的数据结构和好的算法,而好的算法的选择很大程度上取决于描述实际问题的数据结构的选取。

所以,学好数据结构,将是进一步提高学生程序设计水平的关键之一。

数据结构的应用水平是区分软件开发、设计人员水平高低的重要标志之一,缺乏数据结构和算法的深厚功底,很难设计出高水平的具有专业水准的应用程序。

本课程的改革理念是,坚持工程化、实用化教学,密切适应计算机技术的发展趋势,坚持学以致用;解决抽象理论与实践相脱节现象,让绝大多数学生在有限的时间内迅速掌握课程的基本理论知识,并把理论知识应用到软件开发的实际工作中,开发出高质是的应用软件。

(二)课程设计思路课程资源建设遵循三个原则、一个过程、四个应用层次。

课程内容的选取遵循科学性原则,课程内容的选取依据数据结构课程在学科体系的理论体系,结合其在实际开发中的使用频度及难易程度,选取适合高职学生的学习内容;课程内容的组织遵循情境性原则,所有模块的内容按一个过程进行组织。

课程内容置于由实践情境建构的以软件开发过程主要逻辑为主线的行动体系之中,采用打碎、集成的思想,将学科体系中所涉及的概念、方法、原理打碎,然后按照软件开发过程逻辑重新集成。

课程资源的建设充分体现人本性原则,按人类掌握知识的基本规律“获取—>内化—>实践—>反思—>新的获取”,开发四个实践层次“验证性应用、训练性应用、设计性应用、创造性应用”的训练题库。

二、培养目标(一)总体目标《数据结构》课程以培养学生的数据抽像能力和复杂程序设计的能力为总目标。

02331《数据结构》自考——各章要点

02331《数据结构》自考——各章要点

自考《数据结构》各章要点一第一章概论数据就是指能够被计算机识别、存储和加工处理的信息的载体。

数据元素是数据的基本单位,可以由若干个数据项组成。

数据项是具有独立含义的最小标识单位。

数据结构的定义:·逻辑结构:从逻辑结构上描述数据,独立于计算机。

·线性结构:一对一关系。

·线性结构:多对多关系。

·存储结构:是逻辑结构用计算机语言的实现。

·顺序存储结构:如数组。

·链式存储结构:如链表。

·稠密索引:每个结点都有索引项。

·稀疏索引:每组结点都有索引项。

·散列存储结构:如散列表。

·对数据的操作:定义在逻辑结构上,每种逻辑结构都有一个运算集合。

·常用的有:检索、插入、删除、更新、排序。

·数据类型:是一个值的集合以及在这些值上定义的一组操作的总称。

·原子类型:由语言提供。

·结构类型:由用户借助于描述机制定义,是导出类型。

抽象数据类型ADT:·是抽象数据的组织和与之的操作。

相当于在概念层上描述问题。

·优点是将数据和操作封装在一起实现了信息隐藏。

程序设计的实质是对实际问题选择一种好的数据结构,设计一个好的算法。

算法取决于数据结构。

算法是一个良定义的计算过程,以一个或多个值输入,并以一个或多个值输出。

评价算法的好坏的因素:·算法是正确的;·执行算法的时间;·执行算法的存储空间(主要是辅助存储空间);·算法易于理解、编码、调试。

时间复杂度:是某个算法的时间耗费,它是该算法所求解问题规模n的函数。

渐近时间复杂度:是指当问题规模趋向无穷大时,该算法时间复杂度的数量级。

评价一个算法的时间性能时,主要标准就是算法的渐近时间复杂度。

算法中语句的频度不仅与问题规模有关,还与输入实例中各元素的取值相关。

时间复杂度按数量级递增排列依次为:常数阶O(1)、对数阶O(log2n)、线性阶O(n)、线性对数阶O(nlog2n)、平方阶O(n^2)、立方阶O(n^3)、……k次方阶O(n^k)、指数阶O(2^n)。

《数据结构与算法》知识点整理

《数据结构与算法》知识点整理

《数据结构与算法》知识点整理《数据结构与算法》知识点整理1:数据结构概述1.1 什么是数据结构1.2 数据结构的作用1.3 数据结构的分类1.4 数据结构的存储方式2:线性表2.1 顺序表2.1.1 顺序表的定义2.1.2 顺序表的基本操作2.2 链表2.2.1 链表的定义2.2.2 链表的基本操作2.3 栈2.3.1 栈的定义2.3.2 栈的基本操作2.4 队列2.4.1 队列的定义2.4.2 队列的基本操作3:树3.1 树的基本概念3.1.1 结点3.1.2 父节点、子节点、兄弟节点 3.2 二叉树3.2.1 二叉树的定义3.2.2 二叉树的遍历方式3.3 平衡二叉树3.3.1 平衡二叉树的定义3.3.2 平衡二叉树的实现4:图4.1 图的基本概念4.1.1 顶点4.1.2 边4.1.3 权重4.2 图的表示方式4.2.1 邻接矩阵4.2.2 邻接表4.3 图的搜索算法4.3.1 深度优先搜索 4.3.2 广度优先搜索5:排序算法5.1 冒泡排序5.2 插入排序5.3 选择排序5.4 快速排序5.5 归并排序6:查找算法6.1 顺序查找6.2 二分查找6.3 哈希查找7:字符串匹配算法7.1 暴力匹配算法7.2 KMP算法7.3 Boyer-Moore算法8:动态规划算法8.1 动态规划的基本概念8.2 0-1背包问题8.3 最长公共子序列问题9:附件9.1 Examples:docx - 包含各章节示例代码的附件文件10:法律名词及注释10:1 数据结构 - 在计算机科学中,数据结构是计算机中存储、组织数据的方式。

10:2 线性表 - 线性表是数据元素的有限序列,元素之间具有线性关系。

10:3 顺序表 - 顺序表是用一组地址连续的存储单元依次存储线性表的元素。

10:4 链表 - 链表是一种数据元素按照顺序存放,元素之间通过指针进行关联的数据结构。

10:5 栈 - 栈是一种特殊的线性表,只能在一端进行插入和删除操作。

《数据结构C语言版》----第02章

《数据结构C语言版》----第02章
int ListLength(SLNode *head) { SLNode *p = head; int size = 0; while(p->next != NULL) { p = p->next; size ++; } return size; }
p size=0
head
a0
a1
(a)
...
a n 1 ∧
3.顺序表操作的效率分析
时间效率分析: 算法时间主要耗费在移动元素的操作上,因此计算时间复 杂度的基本操作(最深层语句频度) T(n)= O(移动元素次数) 而移动元素的个数取决于插入或删除元素的位置i. 若i=size,则根本无需移动(特别快); 若i=0,则表中元素全部要后移(特别慢); 应当考虑在各种位置插入(共n+1种可能)的平均移动次 数才合理。
(3)带头结点单链表和不带头结点单链表的比较
1).在带头结点单链表第一个数据元素前插入结点
p head s p head data next a0 x

a1

an-1

(a) 插入前
data next a0

a1

an-1

s
x
(b) 插入后
2).删除带头结点单链表第一个数据元素结点
p data next head
(5)取数据元素ListGet(L,
i, x)
int ListGet(SeqList L, int i, DataType *x) { if(i < 0 || i > L.size-1) { printf("参数i不合法! \n"); return 0; } else { *x = L.list[i]; return 1; } }

《数据结构与算法》链表的遍历与数组存储

《数据结构与算法》链表的遍历与数组存储

《数据结构与算法》链表的遍历与数组存储链表是一种常用的数据结构,它由一系列节点组成,每个节点包含数据和指向下一个节点的指针。

链表的遍历是指按照一定的顺序访问链表中的每个节点,而数组存储则是指将链表中的数据存储在一个数组中。

本文将分别介绍链表的遍历和数组存储,并对它们进行比较。

一、链表的遍历链表的遍历是指按照一定的顺序访问链表中的每个节点。

链表的遍历可以采用两种常见的方式:头结点遍历和指针遍历。

1. 头结点遍历头结点遍历是指从链表的头结点开始,依次遍历每个节点直到链表的尾节点。

具体步骤如下:(1)定义一个指针指向链表的头结点;(2)通过循环遍历链表,直到指针指向空节点为止;(3)在每次循环中,输出当前节点的数据,并将指针指向下一个节点。

2. 指针遍历指针遍历是指通过一个指针依次遍历链表中的每个节点。

具体步骤如下:(1)定义一个指针指向链表的第一个节点;(2)通过循环遍历链表,直到指针指向空节点为止;(3)在每次循环中,输出当前节点的数据,并将指针指向下一个节点。

链表的遍历可以用来查找、插入、删除等操作,是链表常用的操作之一。

相比数组存储,链表的遍历不需要提前知道链表的长度,具有更好的灵活性。

二、数组存储数组存储是指将链表中的数据存储在一个数组中。

具体步骤如下:(1)首先,遍历链表获取链表的长度;(2)根据链表的长度创建一个对应大小的数组;(3)再次遍历链表,将链表中的数据逐个存储到数组中。

数组存储的优点是可以通过下标快速访问数组中的元素,时间复杂度为O(1)。

而链表的遍历需要从头结点开始依次查找,时间复杂度为O(n),其中n为链表的长度。

因此,在需要频繁访问链表中的元素时,数组存储更加高效。

三、链表的遍历与数组存储的比较链表的遍历和数组存储都可以实现对链表中数据的访问,但它们的实现方式和特点有所不同。

1. 空间复杂度链表的遍历不需要额外的存储空间,只需要一个指针来指向当前节点,因此空间复杂度为O(1)。

数据结构实验报告-线性表

数据结构实验报告-线性表

1 线性表1. 实验题目与环境1.1实验题目及要求(1)顺序表的操作利用顺序存储方式实现下列功能:根据键盘输入数据建立一个线性表,并输出该线性表;对该线性表进行数据的插入、删除、查找操作,并在插入和删除数据后,再输出线性表。

(2)单链表的操作利用链式存储方式实现下列功能:根据键盘输入数据建立一个线性表,并输出该线性表;对该线性表进行数据的插入、删除、查找操作,并在插入和删除数据后,再输出线性表。

(3)线性表的应用约瑟夫环问题。

有n个人围坐一圈,现从某个人开始报数,数到M的人出列,接着从出列的下一个人开始重新报数,数到M的人又出列,如此下去,直到所有人都出列为止。

要求依次输出出列人的编码。

2.问题分析(1)顺序表的操作利用一位数组来描述顺序表,即将所有元素一词储存在数组的连续单元中,要在表头或中间插入一个新元素时,需要将其后的所有元素都向后移动一个位置来为新元素腾出空间。

同理,删除开头或中间的元素时,则将其后的所有元素向前移动一个位置以填补空位。

查找元素时,则需要利用循环语句,一一判断直到找出所要查找的元素(或元素的位置),输出相关内容即可(2)单链表的操作利用若干个结点建立一个链表,每个节点有两个域,即存放元素的数据域和存放指向下一个结点的指针域。

设定一个头指针。

在带头结点的单链表中的第i个元素之前插入一新元素,需要计数找到第i-1个结点并由一指针p指向它,再造一个由一指针s指向的结点,数据为x,并使x的指针域指向第i个结点,最后修改第i-1个结点的指针域,指向x结点。

删除第i个元素时,需要计数寻找到第i个结点,并使指针p指向其前驱结点,然后删除第i个结点并释放被删除结点的空间。

查找第i个元素,需从第一个结点开始计数找到第i个结点,然后输出该结点的数据元素。

(3)线性表的应用程序运行之后,首先要求用户指定初始报数的上限值,可以n<=30,此题中循环链表可不设头结点,而且必须注意空表和"非空表"的界限。

数据结构c++顺序表、单链表的基本操作,查找、排序代码

数据结构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、编写程序实现顺序表的各种基本运算:初始化、插⼊、删除、取表元素、求表长、输出表、销毁、判断是否为空表、查找元素。

在此基础上设计⼀个主程序完成如下功能:(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 }。

《数据结构与算法》课件 第3章 链表

《数据结构与算法》课件 第3章 链表

练习
1、链表中逻辑上相邻的元素在物理上()相邻。 2、已知带头结点的单链表L,指针p指向链表中的一个节点, 指针q指向链表外的节点,在指针p的后面插入q的语句序 列( ) 3、设某非空单链表,要删除指针p所指的结点的直接后继结 点,则需要执行下述语句序列: p=q->next; ( );free(p); 4、线性表的存储有顺序存储和( )存储两种。 5、线性表中哪些元素只有一个直接前驱和一个直接后继? A 首元素 b 尾元素 c 中间的元素 d 所有的元素 6、线性表的各元素之间是()关系 A 层次 b 网状 c 有序 d 集合 7、在单链表中一个结点有()个指针,在双向链表中的一 个结点有()指针
2、求长度 L 21 18 p k p
30
p
75
p
42
p
56 ∧
p p
6 5 4 3 2 1 0
int list_length(LinkList L) {int n=0; LinkList p=L->next; while(p!=NULL) { n++;p=p->next;} return n; }
exit(0);}
s=(SNode *) malloc(sizeof(SNode)); sdata=x; snext=prenext; prenext=s; }
5、删除算法的实现
void LinkListDelete(LinkList L,int i)
……..
ai-1
ai
ai+1
……..
P
相互之间的关系是靠其中的后继地址来表示的
动态链表:根据实际需要临时分配
结构描述如下: typedef struct SNode{ ElemType data; struct SNode *next; //指向结构体类型指针 }*LinkList;

【数据结构】线性表的基本操作

【数据结构】线性表的基本操作

【数据结构】线性表的基本操作在计算机科学中,数据结构是组织和存储数据的方式,以便能够高效地对数据进行操作和处理。

线性表作为一种常见的数据结构,具有重要的地位和广泛的应用。

接下来,让我们深入了解一下线性表的基本操作。

线性表,简单来说,就是数据元素排成的线性序列。

就像一排整齐的士兵,每个士兵都是一个数据元素。

它可以分为顺序表和链表两种实现方式。

先来说说顺序表。

顺序表是把线性表中的元素依次存放在一组地址连续的存储单元中。

想象一下,这就像是在一个连续的柜子里,一格一格地存放着物品。

在顺序表中,访问元素非常方便,只要知道元素的位置,就能迅速找到它。

比如要找第 5 个元素,直接去第 5 个存储单元就行。

顺序表的基本操作之一是插入元素。

假设我们要在顺序表的第 3 个位置插入一个新元素,那可就有点麻烦了。

首先,要从最后一个元素开始,依次向后移动一位,给新元素腾出位置。

然后,把新元素放到第 3 个位置。

这就像是在一排已经坐好的人中间插入一个新的人,后面的人都得往后挪一挪。

删除元素的操作也类似。

如果要删除第 3 个元素,先把第 3 个元素取出来,然后从第 4 个元素开始,依次向前移动一位。

这就像是把一排人中的某个人请出去,后面的人都要往前坐。

再说说链表。

链表中的元素可以存放在内存中的任意位置,通过指针把它们串起来。

这就像是用绳子把分散的珠子串起来一样。

链表的插入操作相对简单一些。

比如要在链表的第 3 个位置插入一个新元素,只需要找到第 2 个元素,然后让它的指针指向新元素,新元素的指针再指向原来第 3 个元素就行了。

删除操作也不复杂。

要删除第 3 个元素,找到第 2 个元素,让它的指针直接指向第 4 个元素,这样第 3 个元素就从链表中脱离了。

接下来看看查找操作。

在顺序表中查找元素,可以直接通过位置快速访问。

但在链表中,就需要从链表的头开始,沿着指针一个一个地找,直到找到目标元素或者找遍整个链表都没找到为止。

还有创建线性表的操作。

数据结构实验报告_单链表

数据结构实验报告_单链表

数据结构实验报告_单链表【实验目的】1、顺序表的基本操作及c语言实现【实验要求】1、用c语言建立自己的线性表结构的程序库,实现顺序表的基本操作。

2、对线性表表示的集合,集合数据由用户从键盘输入(数据类型为整型),建立相应的顺序表,且使得数据按从小到大的顺序存放,将两个集合的并的结果存储在一个新的线性表集合中,并输出。

【实验内容】1、根据教材定义的顺序表机构,用c语言实现顺序表结构的创建、插入、删除、查找等操作;2、利用上述顺序表操作实现如下程序:建立两个顺序表表示的集合(集合中无重复的元素),并求这样的两个集合的并。

【实验结果】[实验数据、结果、遇到的问题及解决]一.statusinsertorderlist(sqlist&va,elemtypex){}二.statusdeletek(sqlist&a,inti,intk){//在非递减的顺序表va中插入元素x并使其仍成为顺序表的算法inti;if(v==ze)return(overflow);for(i=v;i>0,x }//注意i的编号从0开始intj;if(i<0||i>-1||k<0||k>-i)returninfeasible;for(j=0;j<=k;j++)[j+i]=[j+i+k];=-k;returnok;三.//将合并逆置后的结果放在c表中,并删除b表statuslistmergeoppose_l(linklist&a,linklist&b,linklist& c){linklistpa,pb,qa,qb;pa=a;pb=b;qa=pa;qb=pb;//保存pa的前驱指针//保存pb的前驱指针pa=pa->next;pb=pb->next;a->next=null;c=a;while(pa&&pb){}whi le(pa){}qa=pa;pa=pa->next;qa->next=a->next;a->next=qa;if(pa ->datadata){}else{}qb=pb;pb=pb->next;qb->next=a->next;//将当前最小结点插入a表表头a->next=qb;qa=pa;pa=pa->next;qa->next=a->next;//将当前最小结点插入a表表头a->next=qa;}}pb=b;free(pb);returnok;qb=pb;pb=pb->next;qb->next=a->n ext;a->next=qb;顺序表就是把线性表的元素存储在数组中,元素之间的关系直接通过相邻元素的位置来表达。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
Display_SeqList(L);//顺序表的输出 Insert_SeqList(L,4,3)6,21); Insert_SeqList(L,2,15); Delete_SeqList(L,5);//顺序表的删除 Delete_SeqList(L,3); Delete_SeqList(L,12); return 0; }
顺序表实验结果:
1. 程序清单:
1 shunxubiao.cpp//顺序表源程序文件
#include "shunxubiao.h"
"<<endl;
#include<iostream>
for(int i=0;i<n;i++)
using namespace std;
{
SeqList *Init_SeqList()//顺序表的初始化算法
图 1-1 顺序表操作结果截图 1
链表实验结果: 1. 程序清单:
1 lianbiao.cpp #include "lianbiao.h"
图 1-2 顺序表操作结果截图 2 LinkList Define_LinkList()//链表的创建算法
{ LinkList L; LNode *s,*r; int x; L=r=NULL; cin>>x; while(x!=FLAG) { s=new LNode; s->data=x; if(L==NULL) L=s; else r->next=s; r=s; cin>>x; } if(r!=NULL) r->next=NULL; return L;
} int Delete_LinkListNode(LinkList L,int i)// 链表 的 删除算法
{ cout<<" 将 位 置 为 "<<i<<" 的 元 素 删 除
"<<endl; LinkList p,s; p=Get_LinkList(L,i-1); if(p==NULL) { cout<<"位置错"<<endl; return -1; } if(p->next==NULL) { cout<<"删除错误"<<endl; return 0; } else { s=p->next; p->next=s->next; delete s;
2.编写顺序表输出算法。(内存中开辟的单元数为 8)
3.依次插入 3,21,15 三个数,分别插入在第 4,6 和 2 位置,每插入一次都要输出一次顺序表。
4.删除第 5,第 3 和第 12 个位置上的元素,每删除一个元素都要输出一次顺序表。
单链表实验内容:
1.建立一个带表头结点的单链表(前插入法和尾插入法都可以)。给定的线性表为 L=(12,25,
Inster_LinkList(L,4,3);//链表的插入 Inster_LinkList(L,6,21); Inster_LinkList(L,12,15); Delete_LinkListNode(L,5);//链表的删除 Delete_LinkListNode(L,3); Delete_LinkListNode(L,12); return 0; }
7,42,19,38),元素由键盘输入。
2.编写单链表输出算法。
3.依次插入 3,21,15 三个数,分别插入在第 4,6 和 12 位置,每插入一次都要输出一次单链表。
4.删除第 5,第 3 和第 12 个位置上的元素,每删除一个元素都要输出一次单链表。
四、实验结果:给出程序清单及输入/输出结果。
{ LNode *p=L->next;; int j=1; while(p!=NULL&&j<i) { p=p->next; j++; } return p;
}
int Inster_LinkList(LinkList L,int i,DataType x)//链 表的插入算法
{ cout<<" 把 元 素 "<<x<<" 插 入 到 位 置 "<<i<<"
2. 输入/输出结果截图:
} int Delete_SeqList(SeqList *L,int i)// 顺 序 表 的 删 除算法 {
cout<<" 将 位 置 为 "<<i<<" 的 元 素 删 除 "<<endl;
int j; if(i<1||i>L->last+1) {
cout<<" 不 存 在 第 "<<i<<" 个 元 素 "<<endl;
return 0; } for(j=i;j<=L->last;j++)
L->data[j-1]=L->data[j]; L->last--; cout<<"删除成功"<<endl; Display_SeqList(L); return 1; }
} SeqList,*last;
SeqList *Init_SeqList(); void Define_SeqList(SeqList *L,int n); void Display_SeqList(SeqList *L); int Insert_SeqList(SeqList *L,int i,DataType x); int Delete_SeqList(SeqList *L,int i);
{
顺序表的插入算法
cout<<"请依次输入顺序表中要储存的元素 {
cout<<" 把 元 素 "<<x<<" 插 入 到 位 置 "<<i<<" 上"<<endl;
int j; if(L->last==maxsize-1) {
cout<<"表满"<<endl; return -1; } if(i<=1||i>L->last+2) { cout<<"位置错"<<endl; return 0; } for(j=L->last;j>=i-1;j--) L->data[j+1]=L->data[j]; L->data[i-1]=x; L->last++; cout<<"插入成功"<<endl; Display_SeqList(L); return 1; 2 shunxubiao.h//顺序表头文件 #include<iostream> using namespace std; #define maxsize 15 typedef int DataType; typedef struct { DataType data[maxsize]; int last; 3 Test_shunxubiao.cpp//顺序表主函数 #include "shunxubiao.h" #include<iostream> using namespace std; int main() { SeqList *L;//顺序表的定义 L=Init_SeqList();//顺序表的初始化 Define_SeqList(L,6);//定义顺序表
北华航天工业学院
《数据结构》
课程实验报告
实验题目: 作者所在系部: 作者所在专业: 作者所在班级: 作者学号: 作者姓名: 任课教师姓名: 完成时间:
北华航天工业学院教务处制
一、实验目的
1 掌握线性表的顺序和链式存储结构
2 熟练运用线性表在顺序存储方式下的初始化、创建、输出、插入和删除运算
3 熟练运用线性表在链式存储方式下的创建、输出、插入和删除运算
else
for(i=0;i<=L->last;i++)
return 0;
cout<<L->data[i]<<" ";
}
cout<<endl;
void Define_SeqList(SeqList *L,int n)// 顺 序 表 的 }
定义算法
int Insert_SeqList(SeqList *L,int i,DataType x) //
} void Display_LinkList(LinkList L)//链表的输出算 法
{ cout<<"链表中储存的元素为"<<endl; while(L->next!=NULL) { cout<<"L->next"<<" "; L=L->next; } cout<<endl;
} LNode *Get_LinkList(LinkList L,int i)// 链表 的查 找算法
cin>>L->data[i];
{
L->last++;
SeqList *L;
}
L=new SeqList;
}
if(L)
void Display_SeqList(SeqList *L)//顺序表的输出
相关文档
最新文档