数据结构与及程序设计专题实验报告
程序设计实训实验报告(热门20篇)
![程序设计实训实验报告(热门20篇)](https://img.taocdn.com/s3/m/41aaa7ae80c758f5f61fb7360b4c2e3f57272595.png)
程序设计实训实验报告(热门20篇)c语言是在国内外广泛使用的一种计算机语言。
其语言功能丰富、表达能力强、使用灵活方便、既具有高级语言的优点,又具有低级语言的许多特点,适合编写系统软件。
其功能强大,不仅用在计算机上广泛用在电子,机械等方面上,而且,所有的windows,unix,linux,mac,os/2,无一例外,哪一个不是c 语言写的?很多新型的语言如,c++,java,c,j,perl...都是衍生自c语言。
掌握了c语言,可以说你就掌握了很多门语言。
学习c程序这门课一年了,这是我们学的第一门专业课,在大学里c语言不但是计算机专业的必修课程而且也是非计算机专业学习计算机基础的一门必修课程。
所以作为我这个计算机专业的学生来说当然十分重要,老师在第一节课说过,c语言是计算机的基础,大多数软件都需要用c语言来编写,通过一个年的学习,使我由初步掌握简单的应试知识到完成高难度的深入编程,如我们在编写一个较大的程序时应该把它分开成几个小程序来看,这样会容易得多。
同时,我觉得c语言应该是操作和理论相结合的课程,在不断地编写中去思考,两者是不可分割的。
在学习一年c语言的过程中我也在慢慢探索怎样才能学好c语言,并总结了一点经验:要了解c语言就要从语法规为基础来学习起,首先要是要了解它的结构,比如变量,首先要了解变量的定义方式(格式),其意义是什么(定义变量有什么用);其次就是要我要怎么去运用它(我要用什么型式去应用它)。
在c语言的命令行中所有的语句都是有它自己的一定格式和形式出现在我们面前,所以我们在学习某种语句或命令时你首先要了解的就是它的规则是什么、有什么用、怎么实现等。
这些都是语法基础也是c语言的基础如果把它们都了解很好了,那么你编起程序来就很得心应手了。
比如说ifelse和switchcase这两种条件语句都是用来判断执行功能的,那我要什么时侯用if什么时侯用switch呢?如果你很好地了解它们的结构和作用的话那么就知道:若它的条件分支是多个而且条件的值是整数或是一个字符值时就会选switch而不会选if。
数据结构课程设计实验报告完整版
![数据结构课程设计实验报告完整版](https://img.taocdn.com/s3/m/d6a744a44bfe04a1b0717fd5360cba1aa9118c65.png)
数据结构课程设计实验报告完整版【正文】一、实验目的本实验主要目的是通过实践,掌握数据结构的基本概念、常见数据结构的实现方式以及在实际应用中的应用场景和效果。
二、实验背景数据结构是计算机科学与技术领域中的一个重要概念,是研究数据的组织方式、存储方式、访问方式以及操作等方面的方法论。
在计算机科学领域,数据结构是实现算法和解决问题的基础,因此对数据结构的理解和应用具有重要意义。
三、实验内容本次数据结构课程设计实验主要分为以下几个部分:1. 实验环境的准备:包括选择合适的开发平台、安装必要的软件和工具。
2. 实验数据的收集和处理:通过合适的方式收集实验所需的数据,并对数据进行处理和整理。
3. 数据结构的选择和实现:根据实验需求,选择合适的数据结构,并进行相应的数据结构实现。
4. 数据结构的测试和优化:对所实现的数据结构进行测试,包括性能测试和功能测试,并根据测试结果对数据结构进行优化和改进。
5. 实验报告的撰写:根据实验过程和结果,撰写完整的实验报告,包括实验目的、实验背景、实验内容、实验结果和结论等。
四、实验过程1. 实验环境的准备本实验选择了Visual Studio作为开发平台,安装了相应版本的Visual Studio,并根据官方指引进行了相应的配置和设置。
2. 实验数据的收集和处理本实验选取了一份包含学生信息的数据集,包括学生姓名、学号、性别、年龄等信息。
通过编写Python脚本,成功提取了所需信息,并对数据进行了清洗和整理。
3. 数据结构的选择和实现根据实验需求,我们选择了链表作为数据结构的实现方式。
链表是一种常见的动态数据结构,能够高效地插入和删除元素,适用于频繁插入和删除的场景。
在实现链表时,我们定义了一个节点结构,包含数据域和指针域。
通过指针的方式将节点连接起来,形成一个链式结构。
同时,我们还实现了相关的操作函数,包括插入、删除、查找等操作。
4. 数据结构的测试和优化在完成链表的实现后,我们对其进行了性能测试和功能测试。
数据结构图的实验报告
![数据结构图的实验报告](https://img.taocdn.com/s3/m/1aa879693069a45177232f60ddccda38366be168.png)
数据结构图的实验报告数据结构图的实验报告引言:数据结构图是计算机科学中重要的概念之一。
它是一种用图形表示数据元素之间关系的数据结构,广泛应用于算法设计、程序开发和系统优化等领域。
本实验报告旨在介绍数据结构图的基本原理、实验过程和结果分析。
一、实验目的本次实验的主要目的是掌握数据结构图的基本概念和操作方法,以及通过实验验证其在解决实际问题中的有效性。
具体而言,我们将通过构建一个社交网络关系图,实现对用户关系的管理和分析。
二、实验方法1. 确定数据结构在本次实验中,我们选择了无向图作为数据结构图的基础。
无向图由顶点集和边集组成,每条边连接两个顶点,且没有方向性。
2. 数据输入为了模拟真实的社交网络,我们首先需要输入一组用户的基本信息,如姓名、年龄、性别等。
然后,根据用户之间的关系建立边,表示用户之间的交流和联系。
3. 数据操作基于构建好的数据结构图,我们可以进行多种操作,如添加用户、删除用户、查询用户关系等。
这些操作将通过图的遍历、搜索和排序等算法实现。
三、实验过程1. 数据输入我们首先创建一个空的无向图,并通过用户输入的方式逐步添加用户和用户关系。
例如,我们可以输入用户A和用户B的姓名、年龄和性别,并建立一条边连接这两个用户。
2. 数据操作在构建好数据结构图后,我们可以进行多种操作。
例如,我们可以通过深度优先搜索算法遍历整个图,查找与某个用户具有特定关系的用户。
我们也可以通过广度优先搜索算法计算某个用户的社交网络影响力,即与该用户直接或间接相连的其他用户数量。
3. 结果分析通过实验,我们可以观察到数据结构图在管理和分析用户关系方面的优势。
它能够快速地找到用户之间的关系,帮助我们了解用户的社交网络结构和影响力。
同时,数据结构图也为我们提供了一种可视化的方式来展示用户之间的关系,使得分析更加直观和易于理解。
四、实验结果通过实验,我们成功构建了一个社交网络关系图,并实现了多种数据操作。
我们可以根据用户的姓名、年龄和性别等信息进行查询,也可以根据用户之间的关系进行遍历和排序。
数据结构实验报告总结
![数据结构实验报告总结](https://img.taocdn.com/s3/m/aabf0855c381e53a580216fc700abb68a882ad66.png)
数据结构实验报告总结本次数据结构实验主要涉及到线性表、栈和队列的基本操作,通过实验操作和总结,我对数据结构的相关知识有了更深入的理解和掌握。
首先,我们进行了线性表的实验操作。
线性表是一种数据结构,它是由n(n≥0)个数据元素组成的有限序列。
在实验中,我们学习了线性表的顺序存储结构和链式存储结构。
通过代码实现,我深刻理解了顺序表和链表的存储方式和特点。
在实验过程中,我发现顺序表适合查找操作,而链表适合插入和删除操作。
这让我对线性表的应用场景有了更清晰的认识。
其次,我们进行了栈的实验操作。
栈是一种特殊的线性表,它只能在表的一端进行插入和删除操作。
在实验中,我学习了栈的基本操作,包括入栈和出栈。
通过实际操作,我深刻理解了栈的“先进后出”的特性,以及它在计算机程序设计中的应用。
我发现栈在递归算法、表达式求值和括号匹配等方面有着重要的作用,这让我对栈的实际应用有了更深入的认识。
最后,我们进行了队列的实验操作。
队列是一种特殊的线性表,它只能在表的一端进行插入操作,而在另一端进行删除操作。
在实验中,我学习了队列的基本操作,包括入队和出队。
通过实际操作,我深刻理解了队列的“先进先出”的特性,以及它在计算机程序设计中的重要性。
我发现队列在广度优先搜索、模拟系统等方面有着重要的应用,这让我对队列的实际应用有了更深入的了解。
通过本次数据结构实验,我不仅掌握了线性表、栈和队列的基本操作,还深刻理解了它们在实际应用中的重要性。
我相信这些知识和经验对我的学习和工作都将有着重要的帮助。
在未来的学习和实践中,我将继续加强对数据结构的理解和运用,不断提升自己的编程能力和解决问题的能力。
总之,本次数据结构实验让我受益匪浅,我将继续努力学习和实践,不断提升自己的专业能力。
希望通过不懈的努力,能够在数据结构领域取得更大的成就。
数据结构实验报告2栈、队列、递归程序设计
![数据结构实验报告2栈、队列、递归程序设计](https://img.taocdn.com/s3/m/6ddb160bbed5b9f3f90f1cc9.png)
日期:学号:姓名:
实验名称:实验报告二栈、队列、递归程序设计
实验目的与要求:
2.1栈和队列的基本操作
(1)正确理解栈的先进后出的操作特点,建立初始栈,通过相关操作显示栈底元素。
(2)程序中要体现出建栈过程和取出栈底元素后恢复栈的入栈过程,按堆栈的操作规则打印结果栈中的元素
{
return(s->top==-1);
}
//---出栈函数
int Pop(SeqStack *&s,ElemType &e)
{
if (s->top==-1)
return 0;
e=s->data[s->top];
s->top--;
return 1;
}
//---初始队列函数
void InitQueue(SqQueue *&q)
q->rear=(q->rear+1)%MaxSize;
q->elem[q->rear]=e;
return 1;
}
//---出队列函数
int OutQueue(SqQueue *&q,ElemType &e)
{
if (q->front==q->rear) //队空
return 0;
q->front=(q->front+1)%MaxSize;
printf("(10)栈为%s,",(StackEmpty(s)?"空":"非空"));
printf("队列为%s\n",(QueueEmpty(q)?"空":"非空"));
数据结构实训实验报告
![数据结构实训实验报告](https://img.taocdn.com/s3/m/09fe0a703069a45177232f60ddccda38376be1ad.png)
一、实验背景数据结构是计算机科学中一个重要的基础学科,它研究如何有效地组织和存储数据,并实现对数据的检索、插入、删除等操作。
为了更好地理解数据结构的概念和原理,我们进行了一次数据结构实训实验,通过实际操作来加深对数据结构的认识。
二、实验目的1. 掌握常见数据结构(如线性表、栈、队列、树、图等)的定义、特点及操作方法。
2. 熟练运用数据结构解决实际问题,提高算法设计能力。
3. 培养团队合作精神,提高实验报告撰写能力。
三、实验内容本次实验主要包括以下内容:1. 线性表(1)实现线性表的顺序存储和链式存储。
(2)实现线性表的插入、删除、查找等操作。
2. 栈与队列(1)实现栈的顺序存储和链式存储。
(2)实现栈的入栈、出栈、判断栈空等操作。
(3)实现队列的顺序存储和链式存储。
(4)实现队列的入队、出队、判断队空等操作。
3. 树与图(1)实现二叉树的顺序存储和链式存储。
(2)实现二叉树的遍历、查找、插入、删除等操作。
(3)实现图的邻接矩阵和邻接表存储。
(4)实现图的深度优先遍历和广度优先遍历。
4. 算法设计与应用(1)实现冒泡排序、选择排序、插入排序等基本排序算法。
(2)实现二分查找算法。
(3)设计并实现一个简单的学生成绩管理系统。
四、实验步骤1. 熟悉实验要求,明确实验目的和内容。
2. 编写代码实现实验内容,对每个数据结构进行测试。
3. 对实验结果进行分析,总结实验过程中的问题和经验。
4. 撰写实验报告,包括实验目的、内容、步骤、结果分析等。
五、实验结果与分析1. 线性表(1)顺序存储的线性表实现简单,但插入和删除操作效率较低。
(2)链式存储的线性表插入和删除操作效率较高,但存储空间占用较大。
2. 栈与队列(1)栈和队列的顺序存储和链式存储实现简单,但顺序存储空间利用率较低。
(2)栈和队列的入栈、出队、判断空等操作实现简单,但需要考虑数据结构的边界条件。
3. 树与图(1)二叉树和图的存储结构实现复杂,但能够有效地表示和处理数据。
数据结构实验报告
![数据结构实验报告](https://img.taocdn.com/s3/m/1667a745a66e58fafab069dc5022aaea998f41ab.png)
数据结构实验报告一、实验目的数据结构是计算机科学中重要的基础课程,通过本次实验,旨在深入理解和掌握常见数据结构的基本概念、操作方法以及在实际问题中的应用。
具体目的包括:1、熟练掌握线性表(如顺序表、链表)的基本操作,如插入、删除、查找等。
2、理解栈和队列的特性,并能够实现其基本操作。
3、掌握树(二叉树、二叉搜索树)的遍历算法和基本操作。
4、学会使用图的数据结构,并实现图的遍历和相关算法。
二、实验环境本次实验使用的编程环境为具体编程环境名称,编程语言为具体编程语言名称。
三、实验内容及步骤(一)线性表的实现与操作1、顺序表的实现定义顺序表的数据结构,包括数组和表的长度等。
实现顺序表的初始化、插入、删除和查找操作。
2、链表的实现定义链表的节点结构,包含数据域和指针域。
实现链表的创建、插入、删除和查找操作。
(二)栈和队列的实现1、栈的实现使用数组或链表实现栈的数据结构。
实现栈的入栈、出栈和栈顶元素获取操作。
2、队列的实现采用循环队列的方式实现队列的数据结构。
完成队列的入队、出队和队头队尾元素获取操作。
(三)树的实现与遍历1、二叉树的创建以递归或迭代的方式创建二叉树。
2、二叉树的遍历实现前序遍历、中序遍历和后序遍历算法。
3、二叉搜索树的操作实现二叉搜索树的插入、删除和查找操作。
(四)图的实现与遍历1、图的表示使用邻接矩阵或邻接表来表示图的数据结构。
2、图的遍历实现深度优先遍历和广度优先遍历算法。
四、实验结果与分析(一)线性表1、顺序表插入操作在表尾进行时效率较高,在表头或中间位置插入时需要移动大量元素,时间复杂度较高。
删除操作同理,在表尾删除效率高,在表头或中间删除需要移动元素。
2、链表插入和删除操作只需修改指针,时间复杂度较低,但查找操作需要遍历链表,效率相对较低。
(二)栈和队列1、栈栈的特点是先进后出,适用于函数调用、表达式求值等场景。
入栈和出栈操作的时间复杂度均为 O(1)。
2、队列队列的特点是先进先出,常用于排队、任务调度等场景。
数据结构实验报告
![数据结构实验报告](https://img.taocdn.com/s3/m/1d5106ed32d4b14e852458fb770bf78a64293a48.png)
数据结构实验报告一、实验目的本实验旨在通过对数据结构的学习和实践,掌握基本的数据结构概念、原理及其应用,培养学生的问题分析与解决能力,提升编程实践能力。
二、实验背景数据结构是计算机科学中的重要基础,它研究数据的存储方式和组织形式,以及数据之间的关系和操作方法。
在软件开发过程中,合理选用和使用数据结构,能够提高算法效率,优化内存利用,提升软件系统的性能和稳定性。
三、实验内容本次实验主要涉及以下几个方面的内容:1.线性表的基本操作:包括线性表的创建、插入、删除、查找、修改等操作。
通过编程实现不同线性表的操作,掌握它们的原理和实现方法。
2.栈和队列的应用:栈和队列是常用的数据结构,通过实现栈和队列的基本操作,学会如何解决实际问题。
例如,利用栈实现括号匹配,利用队列实现银行排队等。
3.递归和回溯算法:递归和回溯是解决很多求解问题的常用方法。
通过编程实现递归和回溯算法,理解它们的思想和应用场景。
4.树和二叉树的遍历:学习树和二叉树的遍历方法,包括前序、中序和后序遍历。
通过编程实现这些遍历算法,加深对树结构的理解。
5.图的基本算法:学习图的基本存储结构和算法,包括图的遍历、最短路径、最小生成树等。
通过编程实现这些算法,掌握图的基本操作和应用。
四、实验过程1.具体实验内容安排:根据实验要求,准备好所需的编程环境和工具。
根据实验要求逐步完成实验任务,注意记录并整理实验过程中遇到的问题和解决方法。
2.实验数据采集和处理:对于每个实验任务,根据要求采集并整理测试数据,进行相应的数据处理和分析。
记录实验过程中的数据和结果。
3.实验结果展示和分析:将实验结果进行适当的展示,例如表格、图形等形式,分析实验结果的特点和规律。
4.实验总结与反思:总结实验过程和结果,回顾实验中的收获和不足,提出改进意见和建议。
五、实验结果与分析根据实验步骤和要求完成实验任务后,得到了相应的实验结果。
对于每个实验任务,根据实验结果进行适当的分析。
数据结构实验报告及心得体会
![数据结构实验报告及心得体会](https://img.taocdn.com/s3/m/18c1bde67e192279168884868762caaedc33ba4b.png)
数据结构实验报告及心得体会一、引言数据结构是计算机科学中的重要基础课程,通过实验环节的学习,我们能够更好地掌握和应用数据结构的概念、算法和操作。
本报告旨在总结和分享我们进行的数据结构实验,并提出相应的心得体会。
二、实验一:线性表的实现与应用1. 实验目的本实验旨在通过实现和应用线性表的基本操作,掌握线性表的存储结构和算法。
2. 实验内容我们选择了顺序表和链表两种线性表的实现方式,并实现了插入、删除和查找等基本操作。
通过实验,我们发现顺序表适用于元素个数较少、频繁查找的情况,而链表适用于插入和删除操作较多、元素个数不确定的情况。
3. 实验心得通过实验一,我们深刻认识到数据结构的不同实现方式对算法的影响。
选择合适的数据结构可以提高算法效率,提高程序的性能。
同时,我们也意识到了在实际应用中,根据问题的具体特点选择不同的数据结构才能得到最优解。
三、实验二:栈与队列的应用本实验旨在通过实现和应用栈和队列的基本操作,掌握栈和队列的特性及其在实际应用中的作用。
2. 实验内容我们分别实现了顺序栈、链式栈、顺序队列和链式队列,并实现了入栈、出栈、入队和出队等基本操作。
我们发现栈适用于实现回溯算法、递归算法等,而队列适用于广度优先搜索、线程池等场景。
3. 实验心得通过实验二,我们进一步理解了栈和队列在实际编程中的运用。
它们提供了方便的数据结构,帮助我们解决了许多实际问题。
同时,实验过程中,我们也发现了栈溢出的问题,意识到了合理管理栈空间的重要性。
四、实验三:树与二叉树的实现与应用1. 实验目的本实验旨在通过实现和应用树和二叉树的基本操作,掌握树和二叉树的存储结构和算法。
2. 实验内容我们实现了树和二叉树的基本操作,包括创建、插入、删除和遍历等。
通过实验,我们发现树在表示具有部分层次结构的问题时更合适,而二叉树在表示递归结构时更加方便。
通过实验三,我们深入理解了树和二叉树的特性及其应用。
树和二叉树是许多高级数据结构的基础,熟练掌握它们的操作对于解决实际问题非常重要。
《数据结构》实验指导及实验报告栈和队列
![《数据结构》实验指导及实验报告栈和队列](https://img.taocdn.com/s3/m/31a660eb0342a8956bec0975f46527d3240ca6cf.png)
《数据结构》实验指导及实验报告栈和队列实验四栈和队列⼀、实验⽬的1、掌握栈的结构特性及其⼊栈,出栈操作;2、掌握队列的结构特性及其⼊队、出队的操作,掌握循环队列的特点及其操作。
⼆、实验预习说明以下概念1、顺序栈:2、链栈:3、循环队列:4、链队三、实验内容和要求1、阅读下⾯程序,将函数Push和函数Pop补充完整。
要求输⼊元素序列1 2 3 4 5 e,运⾏结果如下所⽰。
#include#include#define ERROR 0#define OK 1#define STACK_INT_SIZE 10 /*存储空间初始分配量*/#define STACKINCREMENT 5 /*存储空间分配增量*/typedef int ElemType; /*定义元素的类型*/typedef struct{ElemType *base; /*定义栈底部指针*/ElemType *top; /*定义栈顶部指针*/int stacksize; /*当前已分配的存储空间*/}SqStack;int InitStack(SqStack *S); /*构造空栈*/int push(SqStack *S,ElemType e); /*⼊栈操作*/int Pop(SqStack *S,ElemType *e); /*出栈操作*/int CreateStack(SqStack *S); /*创建栈*/void PrintStack(SqStack *S); /*出栈并输出栈中元素*/int InitStack(SqStack *S){S->base=(ElemType *)malloc(STACK_INT_SIZE *sizeof(ElemType)); if(!S->base) return ERROR;S->top=S->base;int Push(SqStack *S,ElemType e){if(S->top-S->base>=S->stacksize){S->base=(ElemType*)realloc(S->base,(S->stacksize+STACKINCREMENT)*sizeof(ElemType)); S->top=S->base+S->stacksize;S->stacksize+=STACKINCREMENT;}*S->top++=e;return 1}/*Push*/int Pop(SqStack *S,ElemType *e){if(S->top!=S->base){*e=*--S->top;return 1;}elsereturn 0;}/*Pop*/int CreateStack(SqStack *S){int e;if(InitStack(S))printf("Init Success!\n");else{printf("Init Fail!\n");return ERROR;}printf("input data:(Terminated by inputing a character)\n"); while(scanf("%d",&e))Push(S,e);return OK;}/*CreateStack*/while(Pop(S,&e))printf("%3d",e);}/*Pop_and_Print*/int main(){SqStack ss;printf("\n1-createStack\n");CreateStack(&ss);printf("\n2-Pop&Print\n");PrintStack(&ss);return 0;}●算法分析:输⼊元素序列1 2 3 4 5,为什么输出序列为5 4 3 2 1?体现了栈的什么特性?2、在第1题的程序中,编写⼀个⼗进制转换为⼆进制的数制转换算法函数(要求利⽤栈来实现),并验证其正确性。
数据结构实验报告
![数据结构实验报告](https://img.taocdn.com/s3/m/43fee53a876fb84ae45c3b3567ec102de2bddfe9.png)
数据结构实验报告
数据结构是一门涉及计算机程序设计以存储、组织和处理数据的学科。
它通过将数据存储在内存中用不同的方式来实现,从而收集、存储、检索和变更数据。
实验室实验旨在演示我们如何使用数据结构在应用程序中创建和处理数据。
学生学习如何实现树形结构、哈希表、链表等数据结构,以及如何使用它们来实现数据结构的基本应用功能,如搜索、排序、插入等。
首先,我们用C语言实现了简单的树形结构,实现了给定数据的搜索、排序和插入功能。
实现这个环境中的这个树形结构需要考虑一些函数,如建立新的节点、插入节点、删除节点、查找节点、计算和分析树结构等。
然后,我们实验室代码测试,确保正确实现和功能。
接下来我们实现哈希表,实现散列函数和拉链法等,用于搜索、插入和删除。
哈希表比树形结构具有更高的存储空间和更快的搜索速度,所以这种结构是数据库和大规模索引中广泛使用的数据结构之一。
最后,我们实现链表,它是一种重要的动态数据结构,可以存储大量的数据,可以快速地更新、插入和删除数据。
通过链表,学生学习了如何实现插入和删除功能,以及如何反式和正向遍历链表。
在实验室练习中,我们学习和掌握了如何使用数据结构,使用数据结构来存储和处理数据,使用不同的数据结构来满足不同的功能要求,以及如何优化实现和操作数据结构的数据结构性能。
此外,本次实验室还提出了使用面向对象编程来实现更复杂的数据结构的思路,可以为学生后续深入研究和实践提供基础。
数据结构--实验报告_线性表的基本操作备用
![数据结构--实验报告_线性表的基本操作备用](https://img.taocdn.com/s3/m/37a7b4689b6648d7c1c74681.png)
实验目的实验内容和要求源代码顺序表的代码单链表的代码测试结果顺序表的测试结果单链表的测试结果五、心得体会实验一线性表的基本操作及其应用一、实验目的1、帮助读者复习C++语言程序设计中的知识。
2、熟悉线性表的逻辑结构。
3、熟悉线性表的基本运算在两种存储结构上的实现。
4、掌握顺序表的存储结构形式及其描述和基本运算的实现。
5、熟练掌握动态链表结构及有关算法的设计二、实验内容题目一:顺序表的基本操作[问题描述]实现顺序表的建立、求长度,取元素、修改元素、插入、删除等顺序表的基本操作。
[基本要求](1)依次从键盘读入数据,建立带头结点的顺序表;(2)输出顺序表中的数据元素(3)求顺序表的长度;(4)根据指定条件能够取元素和修改元素;(5)实现在指定位置插入和删除元素的功能。
(6)根据算法,将两个有序的顺序表合并成一个有序顺序表。
[测试数据] 由学生任意指定。
题目二:单链表的基本操作[问题描述]实现带头结点的单链表的建立、求长度,取元素、修改元素、插入、删除等单链表的基本操作。
[基本要求](1)依次从键盘读入数据,建立带头结点的单链表;(2)输出单链表中的数据元素(3)求单链表的长度;(4)根据指定条件能够取元素和修改元素;(5)实现在指定位置插入和删除元素的功能。
(6)根据算法,将两个有序的单链表合并成一个有序单链表。
[测试数据]由学生任意指定。
三、源代码顺序表的基本操作#include<iostream>using namespace std;#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define OVERFLOW -2typedef int Status;typedef int ElemType;#define LIST_INIT_SIZE 100#define LISTINCREMENT 10typedef struct { //结构体ElemType *elem;int length;int listsize;}SqList;SqList Lx;Status InitList_Sq(SqList &L) //分配空间{ L.elem=new ElemType[LIST_INIT_SIZE];if(!L.elem)exit(OVERFLOW);L.length =0;L.listsize=LIST_INIT_SIZE;return OK;}Status ListInsert(SqList &L,int i,ElemType e) //插入新元素{ int *q,*p;ElemType *newbase;if(i<1 || i>L.length+1) return ERROR;if(L.length>=L.listsize){ newbase=new ElemType[L.listsize+LISTINCREMENT];if(!newbase) exit(OVERFLOW);L.elem=newbase;L.listsize+=LISTINCREMENT;}q=&(L.elem[i-1]);for (p=&(L.elem[L.length-1]);p>=q;--p)*(p+1)=*p;*q=e;++L.length;return OK;}Status Listlength(SqList L) //长度{ int *p=L.elem; //判断线形表是否存在while(p){ return (L.length); }}Status GetElem(SqList L, int i,ElemType &e) //取元素{ if(i<1 || i>L.length)return ERROR;else{ e=L.elem[i-1];return e;}}void MergeList(SqList La,SqList Lb,SqList &Lc) //合并{ ElemType ai,bj;InitList_Sq(Lc);int i=1,j=1,k=0;int La_len,Lb_len;La_len=Listlength(La);Lb_len=Listlength(Lb);while((i<=La_len)&&(j<=Lb_len)){ GetElem(La,i,ai);GetElem(Lb,j,bj);if(ai<=bj){ ListInsert(Lc,++k,ai);++i; }else{ ListInsert(Lc,++k,bj);++j; }}while(i<=La_len){ GetElem(La,i++,ai);ListInsert(Lc,++k,ai);}while(j<=Lb_len){ GetElem(Lb,j++,bj);ListInsert(Lc,++k,bj);}}void show(SqList L,int i) //显示{ int j;ElemType k;cout<<"顺序表显示如下:"<<endl;for(j=0;j<i-1;j++){ k=L.elem[j];cout<<k<<"->"; }if(j==i-1 && i>0){ k=L.elem[j]; cout<<k; }cout<<endl;}void create(SqList &L,int n) //输入元素{ int e;for(int i=0;i<n;i++){ cin>>e;L.elem[i]=e;L.length=i+1; }}Status ListDelete_Sq(SqList &L,int i,ElemType &e) //删除{ ElemType *p, *q;if(i<1 || i>L.length) return ERROR;p=&(L.elem[i-1]);e=*p;q=L.elem+L.length-1;for(++p;p<=q;++p) *(p-1)=*p;--L.length;return OK;}Status Listxiugei(SqList &L,int i,ElemType &e) //修改{ if(i<1 || i>L.length)return ERROR;else{ L.elem[i-1]=e;return OK; }}void shuru(SqList &L1) //顺序表的创建{ int a;InitList_Sq(L1);cout<<"请输入顺序表的长度:";cin>>a;cout<<"请输入顺序表的元素(共"<<a<<"个)"<<endl;create(L1,a);show(L1,a);}void chaxun(SqList &L1) //取第i个位置的元素{ int j;ElemType e1;cout<<"请选择所要取出元素的位置:";cin>>j;while(j<0||j>Listlength(L1)){ cout<<"输入有误,请重新输入"<<endl;cout<<"请选择所要取出元素的位置:";cin>>j; }GetElem(L1,j,e1);cout<<"取出的元素为:"<<e1<<endl; }void xiugai(SqList &L1) //修改第i个位置的元素{ int a;int j; ElemType e1;a=L1.length;cout<<"请选择所要修改元素的位置:";cin>>j;while(j<0||j>Listlength(L1)){ cout<<"输入有误,请重新输入"<<endl;cout<<"请选择所要修改元素的位置:";cin>>j; }cout<<"要修改成的元素:";cin>>e1;Listxiugei(L1,j,e1);cout<<"修改后的顺序表数据:"<<endl;show(L1,a);}void shanchu(SqList &L1) //删除顺序表里的元素{ int a;int j; ElemType e1;a=L1.length;cout<<"请选择所要删除元素的位置:";cin>>j;while(j<0||j>Listlength(L1)){ cout<<"输入有误,请重新输入"<<endl;cout<<"请选择所要删除元素的位置:";cin>>j; }ListDelete_Sq(L1,j,e1);cout<<"修改后的顺序表数据:"<<endl;show(L1,a-1);}void charu(SqList &L1) //插入元素到顺序表里{ int a; int j; ElemType e1;a=L1.length;cout<<"请选择所要插入元素的位置:";cin>>j;while(j<0||j>Listlength(L1)){ cout<<"输入有误,请重新输入"<<endl;cout<<"请选择所要插入元素的位置:";cin>>j; }cout<<"要插入的元素:";cin>>e1;ListInsert(L1,j,e1);cout<<"修改后的顺序表数据:"<<endl;show(L1,a+1);}void hebing(SqList &L3) //合并两个顺序表{ SqList L1,L2;InitList_Sq(L1); InitList_Sq(L2);cout<<"请输入第一个有序表的长度:"; cin>>a;cout<<"请输入第一个有序表的元素(共"<<a<<"个)"<<endl;create(L1,a);show(L1,a);cout<<"请输入第二个有序表的长度:"; cin>>b;cout<<"请输入第二个有序表的元素(共"<<b<<"个)"<<endl;create(L2,b);show(L2,b);MergeList(L1,L2,L3);cout<<"合并后的有序表如下:"; show(L3,a+b);}void main() //主菜单{ int choice;for(;;){ cout<<" 顺序表的基本操作"<<endl;cout<<" 1.顺序表的创建"<<endl;cout<<" 2.顺序表的显示"<<endl;cout<<" 3.顺序表的长度"<<endl;cout<<" 4.取第i个位置的元素"<<endl;cout<<" 5.修改第i个位置的元素"<<endl;cout<<" 6.插入元素到顺序表里"<<endl;cout<<" 7.删除顺序表里的元素"<<endl;cout<<" 8.合并两个顺序表"<<endl;cout<<" 9.退出系统"<<endl;cout<<"请选择:";cin>>choice;switch(choice){ case 1: shuru(Lx);break;case 2: show(Lx,Lx.length);break;case 3: cout<<"顺序表的长度:"<<Listlength(Lx)<<endl;break;case 4: chaxun(Lx);break;case 5: xiugai(Lx);break;case 6: charu(Lx);break;case 7: shanchu(Lx);break;case 8: hebing(Lx);break;case 9: cout<<"退出系统!"<<endl;exit(0);break;default : cout<<"输入有误,请重新选择"<<endl;break; } }}单链表的基本操作#include<iostream>using namespace std;#define false 0#define ok 1#define error 0#define overflow -2typedef int Status;typedef int ElemType;typedef struct LNode //存储结构{ ElemType data;struct LNode *next;}LNode,*LinkList;void CreateList(LinkList &L,int n) //尾插法创建单链表{ LinkList p;L=new LNode;L->next=NULL; //建立一个带头结点的单链表LinkList q=L; //使q指向表尾for(int i=1;i<=n;i++){ p=new LNode;cin>>p->data;p->next=NULL;q->next=p;q=p; }}Status GetElem(LinkList L,int i,ElemType &e)//取第i个元素{ LinkList p=L->next;int j=1;while(p&&j<i){ p=p->next;++j; }if(!p||j>i) return error; //第i个元素不存在e=p->data;return ok;}Status LinkInsert(LinkList &L,int i,ElemType e) //插入{ LinkList p=L;int j=0;while(p&&j<i-1){ p=p->next;++j; } //寻找第i-1个结点if(!p||j>i-1)return error; //i小于1或者大于表长加1LinkList s=new LNode; //生成新结点s->data=e;s->next=p->next; //插入L中p->next=s;return ok;}Status ListDelete(LinkList &L,int i,ElemType &e) // 删除{ LinkList p=L;LinkList q;int j=0;while(p->next&&j<i-1){ //寻找第i个结点,并令p指向其前驱p=p->next;++j; }if(!(p->next)||j>i-1) return error; //删除位置不合理q=p->next;p->next=q->next; //删除并释放结点e=q->data;delete(q);return ok;}void MergeList(LinkList &La,LinkList &Lb,LinkList &Lc){ //合并两个顺序链表LinkList pa,pc,pb;pa=La->next;pb=Lb->next;Lc=pc=La;while(pa&&pb){ if(pa->data<=pb->data){ pc->next=pa;pc=pa;pa=pa->next; }else{ pc->next=pb;pc=pb;pb=pb->next; }}pc->next=pa?pa:pb;delete(Lb);}void show(LinkList L) //显示{ LinkList p;p=L->next;while(p){ cout<<p->data<<"-->";p=p->next; }cout<<endl;}int Length(LinkList L,int i) //表长{ i=0;LinkList p=L->next;while(p){ ++i;p=p->next; }return i;}void xiugai(LinkList L) //修改{ int i,j=1;ElemType k;ElemType e,m;LinkList p=L->next;cout<<"请输入要修改的元素位置(0<i<length):";cin>>i;GetElem(L,i,e);cout<<"该位置的元素:"<<e<<endl;cout<<"修改后的元素值:";cin>>k;while(p&&j<i){ p=p->next;++j; }m=p->data;p->data=k;cout<<"修改后的单链表显示如下:"<<endl;show(L);}void hebing() //合并两个单链表{ int a,b;LinkList La,Lb,Lc;cout<<"请输入第一个有序链表的长度:"<<endl;cin>>a;cout<<"请输入第一个有序链表的元素共("<<a<<"个):"<<endl;CreateList(La,a);show(La);cout<<"请输入第二个有序链表的长度:"<<endl;cin>>b;cout<<"请输入第二个有序链表的元素共("<<b<<"个):"<<endl;CreateList(Lb,b);show (Lb);MergeList(La,Lb,Lc);cout<<"合并后的有序链表如下:"<<endl;show(Lc);}void main() //主函数{ int select;int x;ElemType y;LinkList list;for(;;){ cout<<" 单链表的基本操作"<<endl;cout<<" 1.单链表的创建"<<endl;cout<<" 2.单链表的显示"<<endl;cout<<" 3.单链表的长度"<<endl;cout<<" 4.取第i个位置的元素"<<endl;cout<<" 5.修改第i个位置的元素"<<endl;cout<<" 6.插入元素到单链表里"<<endl;cout<<" 7.删除单链表里的元素"<<endl;cout<<" 8.合并两个单链表"<<endl;cout<<" 9.退出系统"<<endl;cout<<"请选择:";cin>>select;switch(select){ case 1:cout<<"请输入单链表的长度:"<<endl;cin>>x;cout<<"请输入"<<x<<"个元素"<<endl;CreateList(list,x);break;case 2: cout<<"单链表显示如下:"<<endl;show(list);break;case 3: int s;cout<<"单链表的长度为:"<<Length(list,s)<<endl;break;case 4: cout<<"请选择所要取出元素的位置:";cin>>x;while(x<0||x>Length(list,s)){ cout<<"输入有误,请重新输入"<<endl;cout<<"请选择所要取出元素的位置:";cin>>x; }GetElem(list,x,y);cout<<"该位置的元素为:"<<y<<endl;break;case 5: xiugai(list); break;case 6: cout<<"请选择要插入的位置:"; cin>>x;while(x<0||x>Length(list,s)){ cout<<"输入有误,请重新输入"<<endl;cout<<"请选择所要插入元素的位置:";cin>>x; }cout<<"要插入的元素值:";cin>>y;LinkInsert( list,x,y);cout<<"插入后单链表显示如下:"<<endl;show(list);break;case 7: cout<<"请选择要删除的位置:"; cin>>x;while(x<0||x>Length(list,s)){ cout<<"输入有误,请重新输入"<<endl;cout<<"请选择所要删除元素的位置:";cin>>x; }ListDelete(list,x,y);cout<<"要删除的元素值:"<<y<<endl;cout<<"删除后的单链表显示如下:"<<endl;show(list);break;case 8: hebing();break;case 9: exit(0);break;default : cout<<"输入有误,请重新输入"<<endl;break;}}}四、测试结果顺序表的测试结果单链表的测试结果五、心得体会当听到老师说写数据结构实验报告时,我有点惊讶,才学了不到一个月,就要写实验报告。
数据结构课程实验报告
![数据结构课程实验报告](https://img.taocdn.com/s3/m/1ced8d612bf90242a8956bec0975f46526d3a761.png)
数据结构课程实验报告目录1. 实验简介1.1 实验背景1.2 实验目的1.3 实验内容2. 实验方法2.1 数据结构选择2.2 算法设计2.3 程序实现3. 实验结果分析3.1 数据结构性能分析3.2 算法效率比较3.3 实验结论4. 实验总结1. 实验简介1.1 实验背景本实验是数据结构课程的一次实践性操作,旨在帮助学生加深对数据结构的理解和运用。
1.2 实验目的通过本实验,学生将学会如何选择合适的数据结构来解决特定问题,了解数据结构与算法设计的关系并能将其应用到实际问题中。
1.3 实验内容本实验将涉及对一些经典数据结构的使用,如链表、栈、队列等,并结合具体问题进行算法设计和实现。
2. 实验方法2.1 数据结构选择在实验过程中,需要根据具体问题选择合适的数据结构,比如针对需要频繁插入删除操作的情况可选择链表。
2.2 算法设计针对每个问题,需要设计相应的算法来实现功能,要考虑算法的效率和实际应用情况。
2.3 程序实现根据算法设计,编写相应的程序来实现功能,并进行调试测试确保程序能够正确运行。
3. 实验结果分析3.1 数据结构性能分析在实验过程中,可以通过对不同数据结构的使用进行性能分析,如时间复杂度和空间复杂度等,以便选择最优的数据结构。
3.2 算法效率比较实验完成后,可以对不同算法在同一数据结构下的效率进行比较分析,找出最优算法。
3.3 实验结论根据实验结果分析,得出结论并总结经验教训,为后续的数据结构和算法设计提供参考。
4. 实验总结通过本次实验,学生将对数据结构与算法设计有更深入的了解,并能将所学知识应用到实际问题中,提高自己的实践能力和解决问题的能力。
数据结构程序设计报告总结
![数据结构程序设计报告总结](https://img.taocdn.com/s3/m/f8c0745afbd6195f312b3169a45177232f60e42d.png)
数据结构程序设计报告总结
摘要:
1.数据结构概述
2.程序设计方法
3.实际应用案例分析
4.报告总结与展望
正文:
一、数据结构概述
数据结构是计算机科学中研究数据如何存储、组织和管理的一门学科。
它为程序设计提供了基本的结构框架,使得程序能够高效地处理数据。
数据结构主要包括线性结构、树状结构、图形结构等。
在本报告中,我们将重点讨论线性结构及其应用。
二、程序设计方法
1.顺序表:顺序表是一种线性数据结构,通过一组连续的存储单元依次存储数据元素。
顺序表的插入、删除操作相对较慢,但查找操作速度较快。
在程序设计中,我们可以使用循环结构实现顺序表的操作。
2.链表:链表是一种线性数据结构,通过每个数据元素指向下一个元素的方式实现数据存储。
链表的插入、删除操作较快,但查找操作相对较慢。
链表的程序设计可以使用递归或循环结构。
3.栈与队列:栈和队列都是线性数据结构,分别支持后进先出(LIFO)和先进先出(FIFO)的操作。
在程序设计中,我们可以使用循环或条件语句实现
栈和队列的操作。
4.树状结构:树状结构是一种层次化的数据结构,由一个根节点和若干子节点组成。
二叉树、B树、红黑树等都是常见的树状结构。
树状结构的程序设计可以使用递归算法。
5.图形结构:图形结构是一种更为复杂的数据结构,由多个节点和边组成。
图形的程序设计通常使用深度优先搜索(DFS)和广度优先搜索(BFS)算法。
程序设计的实验报告
![程序设计的实验报告](https://img.taocdn.com/s3/m/eddb449acf2f0066f5335a8102d276a20129604a.png)
程序设计的实验报告程序设计的实验报告引言:程序设计是计算机科学中的重要组成部分,通过编写代码实现特定功能。
本实验旨在通过一个实际案例,展示程序设计的过程和技巧,以及解决问题的能力。
实验目的:本次实验的目的是设计一个简单的学生成绩管理系统,能够实现学生成绩的录入、查询和统计功能。
通过这个案例,我们将学习如何使用编程语言来解决实际问题,以及如何设计和实现一个简单的软件系统。
实验步骤:1. 确定需求:首先,我们需要明确系统的功能和用户需求。
在这个案例中,我们需要实现学生信息的录入、成绩的录入和查询、成绩的统计等功能。
同时,我们还需要考虑系统的用户界面和交互方式。
2. 设计数据结构:接下来,我们需要设计合适的数据结构来存储学生信息和成绩数据。
可以使用数组、链表或者其他数据结构来实现。
3. 编写代码:根据需求和设计,我们开始编写代码。
可以选择合适的编程语言,如C++、Java等。
在编写代码的过程中,需要注意代码的可读性和可维护性,以及错误处理和异常处理等方面。
4. 调试和测试:在编写完代码后,我们需要进行调试和测试。
通过输入不同的数据和情况,验证程序的正确性和稳定性。
如果发现错误或者异常情况,需要进行修复和优化。
5. 文档撰写:最后,我们需要撰写实验报告,记录实验的目的、步骤和结果。
实验报告应该清晰、详细地描述实验过程和结果,以便其他人能够理解和复现实验。
实验结果:经过以上步骤,我们成功地设计和实现了一个简单的学生成绩管理系统。
该系统可以实现学生信息的录入、成绩的录入和查询、成绩的统计等功能。
通过该系统,我们可以方便地管理学生成绩,提高工作效率。
实验总结:通过本次实验,我们深入了解了程序设计的过程和技巧。
通过设计和实现一个实际的软件系统,我们掌握了数据结构的设计和使用、编程语言的应用、调试和测试的方法等。
同时,我们也体会到了解决问题的能力和创造力的重要性。
在以后的学习和工作中,我们将继续加强对程序设计的理解和应用。
数据结构专题实验
![数据结构专题实验](https://img.taocdn.com/s3/m/5a8c70f40875f46527d3240c844769eae009a363.png)
上机实验要求及规范《数据结构》课程具有比较强的理论性,同时也具有较强的可应用性和实践性,因此上机实验是一个重要的教学环节。
一般情况下学生能够重视实验环节,对于编写程序上机练习具有一定的积极性,但是容易忽略实验的总结,忽略实验报告的撰写。
对于一名大学生必须严格训练分析总结能力、书面表达能力。
需要逐步培养书写科学实验报告以及科技论文的能力。
拿到一个题目,一般不要急于编程,而是应该按照面向过程的程序设计思路(关于面向对象的训练将在其它后继课程中进行),首先理解问题,明确给定的条件和要求解决的问题,然后按照自顶向下,逐步求精,分而治之的策略,逐一地解决子问题。
具体步骤如下:1.问题分析与系统结构设计充分地分析和理解问题本身,弄清要求做什么(而不是怎么做),限制条件是什么。
按照以数据结构为中心的原则划分模块,搞清数据的逻辑结构(是线性表还是树、图?),确定数据的存储结构(是顺序结构还是链表结构?),然后设计有关操作的函数。
在每个函数模块中,要综合考虑系统功能,使系统结构清晰、合理、简单和易于调试。
最后写出每个模块的算法头和规格说明,列出模块之间的调用关系(可以用图表示),便完成了系统结构设计。
2.详细设计和编码详细设计是对函数(模块)的进一步求精,用伪高级语言(如类C语言)或自然语言写出算法框架,这时不必确定很多结构和变量。
编码,即程序设计,是对详细设计结果的进一步求精,即用某种高级语言(如C/C++语言)表达出来。
尽量多设一些注释语句,清晰易懂。
尽量临时增加一些输出语句,便于差错矫正,在程序成功后再删去它们。
3.上机准备熟悉高级语言用法,如C语言。
熟悉机器(即操作系统),基本的常用命令。
静态检查主要有两条路径,一是用一组测试数据手工执行程序(或分模块进行);二是通过阅读或给别人讲解自己的程序而深入全面地理解程序逻辑,在这个过程中再加入一些注释和断言。
如果程序中逻辑概念清楚,后者将比前者有效。
4.上机调试程序调试最好分块进行,自底向上,即先调试底层函数,必要时可以另写一个调用驱动程序,表面上的麻烦工作可以大大降低调试时所面临的复杂性,提高工作效率。
数据结构实验报告及心得体会
![数据结构实验报告及心得体会](https://img.taocdn.com/s3/m/456dafa49a89680203d8ce2f0066f5335b816769.png)
数据结构实验报告及心得体会一、实验背景和目的本次实验的目的是通过设计和实现常见的数据结构,来加深对数据结构的理解,并能够熟练运用。
实验中使用的数据结构有栈、队列和链表,通过这些数据结构的设计和应用,能够更好地掌握数据结构的原理和应用。
二、实验过程1. 栈的设计和实现在本次实验中,我设计了一个基于数组的栈,用于存储数据。
首先,我定义了一个栈类,包含栈的容量、栈顶指针和存储数据的数组。
然后,我实现了入栈、出栈和判断栈空、栈满的操作。
在测试阶段,我编写了一些测试用例,验证栈的功能和正确性。
2. 队列的设计和实现在本次实验中,我设计了一个基于链表的队列。
首先,我定义了一个队列类,包含队列的头指针和尾指针。
然后,我实现了入队、出队和判断队列空、队列满的操作。
在测试阶段,我编写了一些测试用例,验证队列的功能和正确性。
3. 链表的设计和实现在本次实验中,我设计了一个能够存储任意数据类型的单链表。
首先,我定义了一个链表类,包含链表的头指针和尾指针。
然后,我实现了插入、删除和查找节点的操作。
在测试阶段,我编写了一些测试用例,验证链表的功能和正确性。
三、实验结果和分析通过本次实验,我成功设计和实现了栈、队列和链表这三种常见的数据结构。
在测试阶段,我对这些数据结构进行了充分的测试,验证了它们的功能和正确性。
在测试过程中,我发现栈和队列在实际应用中具有很大的作用。
例如,在计算表达式的过程中,可以利用栈来实现中缀表达式转后缀表达式的功能;在操作系统中,可以利用队列来实现进程的调度。
此外,在实验过程中,我还进一步加深了对数据结构的理解。
通过设计和实现数据结构,我学会了如何根据问题的需求选择合适的数据结构,并能够运用数据结构解决实际问题。
在实现过程中,我遇到了一些问题,例如链表的插入和删除操作需要考虑前后指针的变化,但通过不断的实践和思考,最终成功解决了这些问题。
同时,我还注意到数据结构的时间复杂度和空间复杂度对算法的性能有着重要的影响,因此在设计数据结构时需要充分考虑这些因素。
(完整版)数据结构实验报告全集
![(完整版)数据结构实验报告全集](https://img.taocdn.com/s3/m/1d9ad710d4d8d15abf234e2d.png)
数据结构实验报告全集实验一线性表基本操作和简单程序1.实验目的(1)掌握使用Visual C++ 6.0上机调试程序的基本方法;(2)掌握线性表的基本操作:初始化、插入、删除、取数据元素等运算在顺序存储结构和链表存储结构上的程序设计方法。
2.实验要求(1)认真阅读和掌握和本实验相关的教材内容。
(2)认真阅读和掌握本章相关内容的程序。
(3)上机运行程序。
(4)保存和打印出程序的运行结果,并结合程序进行分析。
(5)按照你对线性表的操作需要,重新改写主程序并运行,打印出文件清单和运行结果实验代码:1)头文件模块#include iostream.h>//头文件#include<malloc.h>//库头文件-----动态分配内存空间typedef int elemtype;//定义数据域的类型typedef struct linknode//定义结点类型{elemtype data;//定义数据域struct linknode *next;//定义结点指针}nodetype;2)创建单链表nodetype *create()//建立单链表,由用户输入各结点data域之值,//以0表示输入结束{elemtype d;//定义数据元素dnodetype *h=NULL,*s,*t;//定义结点指针int i=1;cout<<"建立一个单链表"<<endl;while(1){cout <<" 输入第"<< i <<"结点data域值:";cin >> d;if(d==0) break;//以0表示输入结束if(i==1)//建立第一个结点{h=(nodetype*)malloc(sizeof(nodetype));//表示指针hh->data=d;h->next=NULL;t=h;//h是头指针}else//建立其余结点{s=(nodetype*) malloc(sizeof(nodetype));s->data=d;s->next=NULL;t->next=s;t=s;//t始终指向生成的单链表的最后一个节点}i++;}return h;}3)输出单链表中的元素void disp(nodetype*h)//输出由h指向的单链表的所有data域之值{nodetype *p=h;cout<<"输出一个单链表:"<<endl<<" ";if(p==NULL)cout<<"空表";while(p!=NULL){cout<<p->data<<" ";p=p->next;}cout<<endl;}4)计算单链表的长度int len(nodetype *h)//返回单链表的长度{int i=0;nodetype *p=h;while(p!=NULL){p=p->next;i++;}return i;}5)寻找第i个节点nodetype *find(nodetype *h,int i)//返回第i个节点的指针{nodetype *p=h;int j=1;if(i>len(h)||i<=0)return NULL;//i上溢或下溢celse{while (p!=NULL&&j<1)//查找第i个节点,并由p指向该节点{j++;p=p->next;}return p;} }6)单链表的插入操作nodetype *ins(nodetype *h,int i,elemtype x)//在单链表head中第i个节点//(i>=0)之后插入一个data域为x的节点{nodetype *p,*s;s=(nodetype*)malloc(sizeof(nodetype));//创建节点ss->data=x;s->next=NULL;if(i==0)//i=0:s作为该单链表的第一个节点{s->next=h;h=s;}else{p=find(h,i);//查找第i个节点,并由p指向该节点if(p!=NULL){s->next=p->next;p->next=s;}return h;}}7)单链表的删除操作nodetype *del(nodetype *h,int i)//删除第i个节点{nodetype *p=h, *s;int j=1;if(i==1)//删除第1个节点{h=h->next;free(p);}else{p=find(h,i-1);//查找第i-1个节点,并由p指向该节点 if(p!=NULL&&p->next!=NULL){s=p->next;//s指向要删除的节点p->next=s->next;free(s);}else cout<<"输入i的值不正确"<<endl;}return h;}8)释放节点空间void dispose(nodetype *h)//释放单链表的所有节点占用的空间{nodetype *pa=h,*pb;if(pa!=NULL){pb=pa->next;if(pb==NULL)//只有一个节点的情况free(pa);else{while (pb!=NULL)//有两个及以上节点的情况{free(pa);pa=pb;pb=pb->next;}free(pa);}}}9)主程序模块:#include"slink.h"//包含头文件slinkvoid main(){nodetype *head;//定义节点指针变量head=create();//创建一个单链表disp(head);//输出单链表cout<<"单链表长度:"<<len(head)<<endl;ins(head, 2,0);//在第二个节点之后插入以0为元素的节点 disp(head);//输出新链表del(head,2);//删除第二个节点disp(head);//输出新链表}5.实验结果建立一个单链表:输入第1结点data域值:1输入第2结点data域值:2输入第3结点data域值:3输入第4结点data域值:4输入第5结点data域值:5输入第6结点data域值:6输入第7结点data域值:7输入第8结点data域值:8输入第9结点data域值:9输入第10结点data域值0:输出一个单链表:1 2 3 4 5 6 7 8 9单链表长度:9输出一个单链表:1 02345678 9输出一个单链表:1 2 3 4 5 6 7 8实验二顺序栈的实现1.实验目的掌握顺序栈的基本操作:初始化栈、判栈空否、入栈、出栈、取栈顶数据元素等运算以及程序实现方法。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
数据结构与及程序设计专题实验报告一.实验任务:对于给定的源文档 SourceDoc.txt,1) 统计其中所有字符的频度(某字符的频度等于其出现的总次数除以总字符数),字符包括字母(区分大小写)、标点符号及格式控制符(空格、回车等)。
2) 按频度统计结果构建哈夫曼编码表。
3) 基于哈夫曼编码表进行编码,生成对应的二进制码流,并输出到文件 Encode.dat,完成信源的编码过程。
4) 根据生成的哈夫曼编码表,对二进制码流文件Encode.dat 进行解码,把结果输出到文件 TargetDoc.txt,完成信源的解码过程。
5) 判断 TargetDoc.txt 与 SourceDoc.txt 内容是否一致,以验证编解码系统的正确性。
二.实验内容:1) 线性链表的构建以及排序;2) 哈夫曼树的构建;3) 基于哈夫曼码进行编码;4) 对二进制码进行解码;5)对生成文件与原文件进行比较;三.程序的算法描述四.程序运行结果:五.源程序代码:#include<stdio.h>#include<stdlib.h>#include<math.h>#include <string.h> typedef struct aa {char data;double rate;int count;struct aa *next;struct aa *pre;char haffmancode[120]; }NODE;NODE *creat(char b[]){ NODE *h, *p, *s,*death;int i;h=(NODE*)malloc(sizeof(NODE));p=(NODE*)malloc(size of(NODE));h->next=p;h->pre=NULL;p->pre=h;p->next=NULL;p->data=b[0]; p->count=1.0;for(i=1;b[i]!='\0';i++){s=(NODE*)malloc(sizeof(NODE));s->data=b[i]; s->count=1.0;s->next=NULL; s->pre=p;p->next=s;p=s;}return h;}void fun(NODE* h,int amount){ NODE *p,*q,*death;for(p=h->next;p;p=p->next){for(q=p->next;q;){if(q->data==p->data){(p->count)++;if (q->next == NULL){q->pre->next = NULL;free(q);break;}else{ q->pre->next=q->next;q->next->pre=q->pre;death=q; q=q->next;free(death);}}else q=q->next;}(p->rate)=1.0*(p->count)/amount;//printf("%c:\t%d\t%f\n",p->data,p->count,p->rate) ;}puts("构建链表完成\n");}void outlink(NODE* h,int *n){//printf("%d",amount);NODE* p=(NODE*)malloc(sizeof(NODE)); NODE* s=(NODE*)malloc(sizeof(NODE));int i;char ch;double r;for(p=h->next;p;p=p->next){for(s=p->next;s;s=s->next){if(s->count > p->count){i=p->count;p->count=s->count;s->count=i;ch=p->data;p->data=s->data;s->data=ch;r=p->rate;p->rate=s->rate;s->rate=r;}}}p=h->next;while(p){//printf("%c:\t%d\t%f\n",p->data,p->count,p->rate) ;(*n)++;p=p->next;}puts("排序完成\n");}typedef struct{NODE body;int lchild,rchild,parent;struct Treenode *next;}HTNode, *Tree;typedef char **Huffmancode;void select(Tree &HT,int n,int & s1,int &s2){int i,j;for(i = 1;i <= n;i++)if(!HT[i].parent){s1 = i;break;}for(j = i+1;j <= n;j++)if(!HT[j].parent){s2 = j;break;}for(i = 1;i <= n;i++)if((HT[s1].body.rate>HT[i].body.rate)&&(!HT[i].par ent)&&(s2!=i))s1=i;for(j = 1;j <= n;j++)if((HT[s2].body.rate>HT[j].body.rate)&&(!HT[j].par ent)&&(s1!=j))s2=j;}void Huffmancoding(Tree &HT, Huffmancode &HC, intn,NODE *head,int *wei){HTNode *p;int m=2*n-1,i;int s1,s2;NODE *L=head->next;HT=(Tree)malloc((m+1)*sizeof(HTNode));for(p=HT+1,i=1;i<=n;i++,p++){p->body=*L;L=L->next;p->lchild=0; p->parent=0; p->rchild=0;}for(;i<=m;p++,i++){p->body.rate=0; p->lchild=0; p->parent=0; p->rchild=0;}for(i=n+1;i<=m;i++){select(HT,i-1,s1,s2);HT[s1].parent=i; HT[s2].parent=i; HT[i].lchild=s1; HT[i].rchild=s2;HT[i].body.rate=HT[s1].body.rate+HT[s2].body.rate; }for(i=n+1;i<=m;i++){if(HT[i].parent==0){*wei=i;}}HC=(Huffmancode)malloc((n+1)*sizeof(char *)); char * temp=(char *)malloc(n*sizeof(char)); temp[n-1]='\0';for(i=0;i<n;i++){int start=n-1;for(int f=HT[i].parent,h=i;f;h=f,f=HT[f].parent){ if(HT[f].lchild==h){temp[--start]='0';}else{temp[--start]='1';}}//HC[i]=(char *)malloc((n-start)*sizeof(char)); strcpy(HT[i].body.haffmancode,&temp[start]);}free(temp);FILE *fw;fw=fopen("Statistic.txt","wt");for(i=1;i<n;i++){fprintf(fw,"%c:\t%d\t%f\t%s\n",HT[i].body.data,HT[ i].body.count,HT[i].body.rate,HT[i].body.haffmanco de);}puts("哈夫曼编码完成,Statistic.txt文件生成完毕\n");fclose(fw);}void putdat(NODE* h,FILE *fp,FILE *ft,FILE *fw,Tree &HT,int *wei,int *nc){char qq[10000]={0};int t[10000]={0};int i=0,j=0,n=0,last=*nc;rewind(fp);char pp[10000]={0};//strcpy(pp,"\0");NODE *L=h->next;while(L){i=0;while(i<last){if(L->data==HT[i].body.data)strcpy(L->haffmancode,HT[i].body.haffmancode);i++;}L=L->next;}char cp=fgetc(fp);while(cp!=EOF){L=h->next;while(cp!=L->data)L=L->next;strcat(pp,L->haffmancode);cp=fgetc(fp);}//printf("%s\n\n",pp);i=0;while(pp[i]!='\0'){n=0;while(n<15&&pp[i]!='\0'){if(pp[i]=='1'){t[j]=t[j]|1;}if(n!=14&&pp[i+1]!='\0'){t[j]=t[j]<<1;}n++;i++;}if(pp[i]=='\0'){t[j+1]=0;last=n;break;}j++;}//for(;t[n]!=0;n++);//itoa(t[0],string,2);printf(" string=%s\n",string);fwrite(&t[0],sizeof(char),j-1,fw);i=0;j=0;while(t[j+1]!='\0'){n=14;while(n>=0){double a=pow(2,n);if((t[j]&(int)a)==(int)a){ qq[i]='1';}else {qq[i]='0';}n--;i++;}j++;}n=last-1;while(n>=0){double a=pow(2,n);if((t[j]&(int)a)==(int)a)qq[i]='1';else qq[i]='0';n--;i++;}qq[i]='\0';//printf("%s",qq);int root=*wei;char c;i=0;while(qq[i]!='\0'){ c=qq[i];if(qq[i]=='0'){root=HT[root].lchild;}else{root=HT[root].rchild;}if(HT[root].rchild==0&&HT[root].lchild==0){ fprintf(ft,"%c",HT[root].body.data);root=*wei;}i++;}puts("解码完成,Target.txt文件生成\n");}bool compare(FILE *fp,FILE *ft){rewind(fp);char ch1=fgetc(fp);char ch2=fgetc(ft);while(ch1!=EOF&&ch2!=EOF){if(ch1!=ch2)break;ch1=fgetc(fp);ch2=fgetc(ft);}return ch1==ch2&&ch1==EOF? true:false;}int main(){ FILE *fp;char ch;int cnt=0;char b[10000];if((fp=fopen("source.txt","rt"))==NULL) {printf("\ncan not open file");return 0;}ch=fgetc(fp);while(ch!=EOF){ch=fgetc(fp);b[cnt] = ch;cnt ++;}FILE *fw;fw=fopen("Encode.dat","wb");if(!fw){printf("NO SPACE %s\n");return 0;}int amount=strlen(b);int n=0,m=2*n-1,i;NODE *head;head=creat(b);fun(head,amount);outlink(head,&n);Tree HT;char **HC;float temp;int wei;HT=(Tree)malloc((m+1)*sizeof(HTNode));HC=(Huffmancode)malloc((n)*sizeof(char *)); Huffmancoding(HT,HC,n,head,&wei);FILE *ft;ft=fopen("Target.txt","wt");if(!ft){printf("NO SPACE FOR Target.txt");return 0;}putdat(head,fp,ft,fw,HT,&wei,&n);fclose(ft);fclose(fp);if(!ft){printf("NO SPACE FOR Target.txt");return 0;}fclose(ft);FILE *ftnew;ftnew=fopen("TargetDoc.txt","rt+"); bool result=compare(fp,ftnew); if(result==true){puts("目标文件与原文件一致\n");}elseputs("目标文件与原文件不一致\n");fclose(ftnew);system("pause");return 0;}六.实验总结:从程序的编写来看,感觉这次自己真的学到了好多,特别是对程序的开发流程。