数据结构实验报告西南交大

合集下载

数据结构课程设计实验报告完整版

数据结构课程设计实验报告完整版

数据结构课程设计实验报告完整版【正文】一、实验目的本实验主要目的是通过实践,掌握数据结构的基本概念、常见数据结构的实现方式以及在实际应用中的应用场景和效果。

二、实验背景数据结构是计算机科学与技术领域中的一个重要概念,是研究数据的组织方式、存储方式、访问方式以及操作等方面的方法论。

在计算机科学领域,数据结构是实现算法和解决问题的基础,因此对数据结构的理解和应用具有重要意义。

三、实验内容本次数据结构课程设计实验主要分为以下几个部分:1. 实验环境的准备:包括选择合适的开发平台、安装必要的软件和工具。

2. 实验数据的收集和处理:通过合适的方式收集实验所需的数据,并对数据进行处理和整理。

3. 数据结构的选择和实现:根据实验需求,选择合适的数据结构,并进行相应的数据结构实现。

4. 数据结构的测试和优化:对所实现的数据结构进行测试,包括性能测试和功能测试,并根据测试结果对数据结构进行优化和改进。

5. 实验报告的撰写:根据实验过程和结果,撰写完整的实验报告,包括实验目的、实验背景、实验内容、实验结果和结论等。

四、实验过程1. 实验环境的准备本实验选择了Visual Studio作为开发平台,安装了相应版本的Visual Studio,并根据官方指引进行了相应的配置和设置。

2. 实验数据的收集和处理本实验选取了一份包含学生信息的数据集,包括学生姓名、学号、性别、年龄等信息。

通过编写Python脚本,成功提取了所需信息,并对数据进行了清洗和整理。

3. 数据结构的选择和实现根据实验需求,我们选择了链表作为数据结构的实现方式。

链表是一种常见的动态数据结构,能够高效地插入和删除元素,适用于频繁插入和删除的场景。

在实现链表时,我们定义了一个节点结构,包含数据域和指针域。

通过指针的方式将节点连接起来,形成一个链式结构。

同时,我们还实现了相关的操作函数,包括插入、删除、查找等操作。

4. 数据结构的测试和优化在完成链表的实现后,我们对其进行了性能测试和功能测试。

《数据结构》实验报告

《数据结构》实验报告

《数据结构》实验报告目录一、实验概述 (2)二、实验原理 (2)2.1 数据结构基本概念 (3)2.2 选择的数据结构类型 (4)2.3 实验原理说明 (5)三、实验步骤 (6)3.1 实验准备 (7)3.2 数据结构选择与实现 (7)3.2.1 数据结构类型选择 (9)3.2.2 数据结构实现细节 (9)3.3 实验功能实现 (10)3.3.1 功能一 (11)3.3.2 功能二 (12)四、实验结果与分析 (13)4.1 实验数据 (15)4.2 结果展示 (16)4.2.1 结果一展示 (17)4.2.2 结果二展示 (17)4.3 结果分析 (18)4.3.1 结果一分析 (19)4.3.2 结果二分析 (20)五、实验总结与讨论 (22)5.1 实验总结 (23)5.2 实验中遇到的问题及解决方法 (24)5.3 对数据结构的认识与体会 (25)5.4 对实验教学的建议 (27)一、实验概述本次实验旨在通过实际操作,加深对《数据结构》课程中所学理论知识的理解和掌握。

实验内容围绕数据结构的基本概念、常用算法以及在实际应用中的实现进行设计。

通过本次实验,学生将能够:理解并掌握线性表、栈、队列、链表、树、图等基本数据结构的特点和适用场景。

掌握常用的数据结构操作算法,如插入、删除、查找等,并能够运用这些算法解决实际问题。

学习使用C++、或其他编程语言实现数据结构的操作,提高编程能力和算法设计能力。

本次实验报告将对实验的目的、内容、步骤、结果及分析等方面进行详细阐述,旨在通过实验过程的学习,提高学生对数据结构理论知识的理解和应用能力。

二、实验原理数据结构的基本概念:介绍数据结构的基本定义,包括数据元素、数据集合、数据关系等基本概念,以及数据结构的三要素:逻辑结构、存储结构和运算。

栈和队列:介绍栈和队列的定义、特点、基本运算及其在算法设计中的重要性。

树和二叉树:讲解树的基本概念、二叉树的结构特点、遍历方法、二叉搜索树及其在数据检索中的应用。

数据结构实验实训报告范文

数据结构实验实训报告范文

一、实验目的1. 理解并掌握数据结构的基本概念和常用算法。

2. 学会使用C语言实现线性表、栈、队列、树和图等基本数据结构。

3. 培养动手实践能力,提高编程水平。

二、实验内容1. 线性表(1)顺序表(2)链表2. 栈(1)顺序栈(2)链栈3. 队列(1)顺序队列(2)链队列4. 树(1)二叉树(2)二叉搜索树5. 图(1)邻接矩阵表示法(2)邻接表表示法三、实验环境1. 操作系统:Windows 102. 编程语言:C语言3. 编译器:Visual Studio 20194. 实验软件:C语言开发环境四、实验步骤1. 线性表(1)顺序表1)定义顺序表结构体2)实现顺序表的初始化、插入、删除、查找等基本操作3)编写测试程序,验证顺序表的基本操作(2)链表1)定义链表结构体2)实现链表的创建、插入、删除、查找等基本操作3)编写测试程序,验证链表的基本操作2. 栈(1)顺序栈1)定义顺序栈结构体2)实现顺序栈的初始化、入栈、出栈、判空等基本操作3)编写测试程序,验证顺序栈的基本操作(2)链栈1)定义链栈结构体2)实现链栈的初始化、入栈、出栈、判空等基本操作3)编写测试程序,验证链栈的基本操作3. 队列(1)顺序队列1)定义顺序队列结构体2)实现顺序队列的初始化、入队、出队、判空等基本操作3)编写测试程序,验证顺序队列的基本操作(2)链队列1)定义链队列结构体2)实现链队列的初始化、入队、出队、判空等基本操作3)编写测试程序,验证链队列的基本操作4. 树(1)二叉树1)定义二叉树结构体2)实现二叉树的创建、遍历、查找等基本操作3)编写测试程序,验证二叉树的基本操作(2)二叉搜索树1)定义二叉搜索树结构体2)实现二叉搜索树的创建、遍历、查找等基本操作3)编写测试程序,验证二叉搜索树的基本操作5. 图(1)邻接矩阵表示法1)定义邻接矩阵结构体2)实现图的创建、添加边、删除边、遍历等基本操作3)编写测试程序,验证邻接矩阵表示法的基本操作(2)邻接表表示法1)定义邻接表结构体2)实现图的创建、添加边、删除边、遍历等基本操作3)编写测试程序,验证邻接表表示法的基本操作五、实验结果与分析1. 线性表(1)顺序表实验结果表明,顺序表的基本操作实现正确,测试程序运行稳定。

数据结构课程实验报告

数据结构课程实验报告

数据结构课程实验报告一、实验目的数据结构是计算机科学中一门重要的基础课程,通过本次实验,旨在加深对数据结构基本概念和算法的理解,提高编程能力和解决实际问题的能力。

具体目标包括:1、掌握常见数据结构(如数组、链表、栈、队列、树、图等)的基本操作和实现方法。

2、学会运用数据结构解决实际问题,培养算法设计和分析的能力。

3、提高程序设计的规范性和可读性,培养良好的编程习惯。

二、实验环境本次实验使用的编程语言为C++,开发环境为Visual Studio 2019。

三、实验内容本次实验共包括以下几个部分:(一)线性表的实现与操作1、顺序表的实现定义一个顺序表结构体,包含数据元素数组和表的长度。

实现顺序表的初始化、插入、删除、查找等基本操作。

2、链表的实现定义链表节点结构体,包含数据域和指针域。

实现链表的创建、插入、删除、遍历等操作。

(二)栈和队列的实现与应用1、栈的实现采用顺序存储或链式存储实现栈。

实现栈的入栈、出栈、栈顶元素获取等操作,并应用于表达式求值。

2、队列的实现用循环队列或链式队列实现队列。

实现队列的入队、出队、队头元素获取等操作,应用于模拟排队系统。

(三)树的基本操作与遍历1、二叉树的实现定义二叉树节点结构体,包含数据域、左子树指针和右子树指针。

实现二叉树的创建、插入、删除节点等操作。

2、二叉树的遍历分别实现前序遍历、中序遍历和后序遍历,并输出遍历结果。

(四)图的表示与遍历1、邻接矩阵和邻接表表示图定义图的结构体,使用邻接矩阵和邻接表两种方式存储图的信息。

实现图的创建、添加边等操作。

2、图的遍历分别用深度优先搜索(DFS)和广度优先搜索(BFS)遍历图,并输出遍历序列。

四、实验步骤(一)线性表的实现与操作1、顺序表的实现首先,定义了一个结构体`SeqList` 来表示顺序表,其中包含一个整数数组`data` 用于存储数据元素,以及一个整数`length` 表示表的当前长度。

在初始化函数`InitSeqList` 中,将表的长度初始化为 0,并分配一定的存储空间给数组。

数据结构实训实验报告

数据结构实训实验报告

一、实验背景数据结构是计算机科学中一个重要的基础学科,它研究如何有效地组织和存储数据,并实现对数据的检索、插入、删除等操作。

为了更好地理解数据结构的概念和原理,我们进行了一次数据结构实训实验,通过实际操作来加深对数据结构的认识。

二、实验目的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)二叉树和图的存储结构实现复杂,但能够有效地表示和处理数据。

数据结构实验报告

数据结构实验报告

数据结构实验报告一、实验目的数据结构是计算机科学中重要的基础课程,通过本次实验,旨在深入理解和掌握常见数据结构的基本概念、操作方法以及在实际问题中的应用。

具体目的包括:1、熟练掌握线性表(如顺序表、链表)的基本操作,如插入、删除、查找等。

2、理解栈和队列的特性,并能够实现其基本操作。

3、掌握树(二叉树、二叉搜索树)的遍历算法和基本操作。

4、学会使用图的数据结构,并实现图的遍历和相关算法。

二、实验环境本次实验使用的编程环境为具体编程环境名称,编程语言为具体编程语言名称。

三、实验内容及步骤(一)线性表的实现与操作1、顺序表的实现定义顺序表的数据结构,包括数组和表的长度等。

实现顺序表的初始化、插入、删除和查找操作。

2、链表的实现定义链表的节点结构,包含数据域和指针域。

实现链表的创建、插入、删除和查找操作。

(二)栈和队列的实现1、栈的实现使用数组或链表实现栈的数据结构。

实现栈的入栈、出栈和栈顶元素获取操作。

2、队列的实现采用循环队列的方式实现队列的数据结构。

完成队列的入队、出队和队头队尾元素获取操作。

(三)树的实现与遍历1、二叉树的创建以递归或迭代的方式创建二叉树。

2、二叉树的遍历实现前序遍历、中序遍历和后序遍历算法。

3、二叉搜索树的操作实现二叉搜索树的插入、删除和查找操作。

(四)图的实现与遍历1、图的表示使用邻接矩阵或邻接表来表示图的数据结构。

2、图的遍历实现深度优先遍历和广度优先遍历算法。

四、实验结果与分析(一)线性表1、顺序表插入操作在表尾进行时效率较高,在表头或中间位置插入时需要移动大量元素,时间复杂度较高。

删除操作同理,在表尾删除效率高,在表头或中间删除需要移动元素。

2、链表插入和删除操作只需修改指针,时间复杂度较低,但查找操作需要遍历链表,效率相对较低。

(二)栈和队列1、栈栈的特点是先进后出,适用于函数调用、表达式求值等场景。

入栈和出栈操作的时间复杂度均为 O(1)。

2、队列队列的特点是先进先出,常用于排队、任务调度等场景。

数据结构 实验报告

数据结构实验报告一、实验目的数据结构是计算机科学中非常重要的一门课程,通过本次实验,旨在加深对常见数据结构(如链表、栈、队列、树、图等)的理解和应用,提高编程能力和解决实际问题的能力。

二、实验环境本次实验使用的编程语言为C++,开发工具为Visual Studio 2019。

操作系统为 Windows 10。

三、实验内容1、链表的实现与操作创建一个单向链表,并实现插入、删除和遍历节点的功能。

对链表进行排序,如冒泡排序或插入排序。

2、栈和队列的应用用栈实现表达式求值,能够处理加、减、乘、除和括号。

利用队列实现银行排队系统的模拟,包括顾客的到达、服务和离开。

3、二叉树的遍历与操作构建一棵二叉树,并实现前序、中序和后序遍历。

进行二叉树的插入、删除节点操作。

4、图的表示与遍历用邻接矩阵和邻接表两种方式表示图。

实现图的深度优先遍历和广度优先遍历。

四、实验步骤及结果1、链表的实现与操作首先,定义了链表节点的结构体:```cppstruct ListNode {int data;ListNode next;ListNode(int x) : data(x), next(NULL) {}};```插入节点的函数:```cppvoid insertNode(ListNode& head, int val) {ListNode newNode = new ListNode(val);head = newNode;} else {ListNode curr = head;while (curr>next!= NULL) {curr = curr>next;}curr>next = newNode;}}```删除节点的函数:```cppvoid deleteNode(ListNode& head, int val) {if (head == NULL) {return;}ListNode temp = head;head = head>next;delete temp;return;}ListNode curr = head;while (curr>next!= NULL && curr>next>data!= val) {curr = curr>next;}if (curr>next!= NULL) {ListNode temp = curr>next;curr>next = curr>next>next;delete temp;}}```遍历链表的函数:```cppvoid traverseList(ListNode head) {ListNode curr = head;while (curr!= NULL) {std::cout << curr>data <<"";curr = curr>next;}std::cout << std::endl;}```对链表进行冒泡排序的函数:```cppvoid bubbleSortList(ListNode& head) {if (head == NULL || head>next == NULL) {return;}bool swapped;ListNode ptr1;ListNode lptr = NULL;do {swapped = false;ptr1 = head;while (ptr1->next!= lptr) {if (ptr1->data > ptr1->next>data) {int temp = ptr1->data;ptr1->data = ptr1->next>data;ptr1->next>data = temp;swapped = true;}ptr1 = ptr1->next;}lptr = ptr1;} while (swapped);}```测试结果:创建了一个包含 5、3、8、1、4 的链表,经过排序后,输出为 1 3 4 5 8 。

数据结构实验报告

数据结构实验报告一、实验目的本实验旨在通过对数据结构的学习和实践,掌握基本的数据结构概念、原理及其应用,培养学生的问题分析与解决能力,提升编程实践能力。

二、实验背景数据结构是计算机科学中的重要基础,它研究数据的存储方式和组织形式,以及数据之间的关系和操作方法。

在软件开发过程中,合理选用和使用数据结构,能够提高算法效率,优化内存利用,提升软件系统的性能和稳定性。

三、实验内容本次实验主要涉及以下几个方面的内容:1.线性表的基本操作:包括线性表的创建、插入、删除、查找、修改等操作。

通过编程实现不同线性表的操作,掌握它们的原理和实现方法。

2.栈和队列的应用:栈和队列是常用的数据结构,通过实现栈和队列的基本操作,学会如何解决实际问题。

例如,利用栈实现括号匹配,利用队列实现银行排队等。

3.递归和回溯算法:递归和回溯是解决很多求解问题的常用方法。

通过编程实现递归和回溯算法,理解它们的思想和应用场景。

4.树和二叉树的遍历:学习树和二叉树的遍历方法,包括前序、中序和后序遍历。

通过编程实现这些遍历算法,加深对树结构的理解。

5.图的基本算法:学习图的基本存储结构和算法,包括图的遍历、最短路径、最小生成树等。

通过编程实现这些算法,掌握图的基本操作和应用。

四、实验过程1.具体实验内容安排:根据实验要求,准备好所需的编程环境和工具。

根据实验要求逐步完成实验任务,注意记录并整理实验过程中遇到的问题和解决方法。

2.实验数据采集和处理:对于每个实验任务,根据要求采集并整理测试数据,进行相应的数据处理和分析。

记录实验过程中的数据和结果。

3.实验结果展示和分析:将实验结果进行适当的展示,例如表格、图形等形式,分析实验结果的特点和规律。

4.实验总结与反思:总结实验过程和结果,回顾实验中的收获和不足,提出改进意见和建议。

五、实验结果与分析根据实验步骤和要求完成实验任务后,得到了相应的实验结果。

对于每个实验任务,根据实验结果进行适当的分析。

西南交通大学数据结构课程设计报告


了解: 迪杰斯特拉算法用于求解一个有向图(也可以是无向图,无向图是有向图的一 种特例)的一个点(称之为原点)到其余各点(称之为周边点)的最短路径问题。算 法构思很是巧妙(我这么认为),简直达到了“无心插柳柳成荫”的境界。算法本身 并不是按照我们的思维习惯——求解从原点到第一个点的最短路径,再到第二个点的 最短路径,直至最后求解完成到第 n 个点的最短路径,而是求解从原点出发的各有向 路径的从小到大的排列(如果这个有向图中有环 1-2-3-1 算法岂不是永无终结之日 了??!!),但是算法最终确实得到了从原点到图中其余各点的最短路径,可以说 这是个副产品,对于算法的终结条件也应该以求得了原点到图中其余各点的最短路径 为宜。清楚了算法的这种巧妙构思后,理解算法本身就不是难题了。 算 法 把 一 个 图 ( G ) 中 的 点 划 分 成 了 若 干 部 分 : 1 ) : 原 点 ( v ) ; 2 ) : 所 有 周 边 点 ( C ) ; 另外有一个辅助集合 S,从 v 到 S 中的点的最短路径已经求得。S 的最初状态是空集。 这 样 就 可 以 进 一 步 划 分 图 ( G ) : 1 ) : 原 点 ( v ) ; 2 ) : 已 求 出 v 至 其 最 短 路 径 的 周 边 点 ( S ) ; 3 ) : 尚 未 求 出 v 至 其 最 短 路 径 的 周 边 点 ( Other=C-S ) ; 算 法 的 主 体 思 想 : A、找到 v——Other 所有路径中的的最短路径 vd=v——d ( Other 的一个元素); B、找到 v——S——Other 所有路径中的的最短路径 vi=v——i(Other 的一个元素); C、比较 vd 和 vi 如果 vd<=vi 则将 d 加入 S 且从 Other 中删除,否则将 i 加入 S 且从 Other 中 删 除 。 重 复 以 上 步 骤 直 至 Other 为 空 集 。 我们求得的最短路径是升序排列的,那为什么下一条最短路径就存在于 v—— 用 找 然 到 了 贪 心 的 策 最 短 的 未 拓 展 节 点 , 加 入 已 拓 展 后 再 根 据 此 节 点 , 重 新 更 新 未 拓 展 略 分 分

数据结构的实验报告

一、实验目的本次实验旨在让学生掌握数据结构的基本概念、逻辑结构、存储结构以及各种基本操作,并通过实际编程操作,加深对数据结构理论知识的理解,提高编程能力和算法设计能力。

二、实验内容1. 线性表(1)顺序表1)初始化顺序表2)向顺序表插入元素3)从顺序表删除元素4)查找顺序表中的元素5)顺序表的逆序操作(2)链表1)创建链表2)在链表中插入元素3)在链表中删除元素4)查找链表中的元素5)链表的逆序操作2. 栈与队列(1)栈1)栈的初始化2)入栈操作3)出栈操作4)获取栈顶元素5)判断栈是否为空(2)队列1)队列的初始化2)入队操作3)出队操作4)获取队首元素5)判断队列是否为空3. 树与图(1)二叉树1)创建二叉树2)遍历二叉树(前序、中序、后序)3)求二叉树的深度4)求二叉树的宽度5)二叉树的镜像(2)图1)创建图2)图的深度优先遍历3)图的广度优先遍历4)最小生成树5)最短路径三、实验过程1. 线性表(1)顺序表1)初始化顺序表:创建一个长度为10的顺序表,初始化为空。

2)向顺序表插入元素:在顺序表的第i个位置插入元素x。

3)从顺序表删除元素:从顺序表中删除第i个位置的元素。

4)查找顺序表中的元素:在顺序表中查找元素x。

5)顺序表的逆序操作:将顺序表中的元素逆序排列。

(2)链表1)创建链表:创建一个带头结点的循环链表。

2)在链表中插入元素:在链表的第i个位置插入元素x。

3)在链表中删除元素:从链表中删除第i个位置的元素。

4)查找链表中的元素:在链表中查找元素x。

5)链表的逆序操作:将链表中的元素逆序排列。

2. 栈与队列(1)栈1)栈的初始化:创建一个栈,初始化为空。

2)入栈操作:将元素x压入栈中。

3)出栈操作:从栈中弹出元素。

4)获取栈顶元素:获取栈顶元素。

5)判断栈是否为空:判断栈是否为空。

(2)队列1)队列的初始化:创建一个队列,初始化为空。

2)入队操作:将元素x入队。

3)出队操作:从队列中出队元素。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

实验一一元稀疏多项式的计算“my.h”#pragma once#include<stdio.h>#include<stdlib.h>#include<string.h>#include<conio.h>#define CLS system("cls");#define PAUSE system("pause");typedef struct Item{double num;int e;struct Item *next;}item,*link;int menu(void);int judge(link,char*);void remove(link);link copy1(link,link);link copy2(link,link);int search(link,int,double);void sort(link);link add(link,link);link subtract(link,link);link multiply(link,link);link input(void);void output(link,char*);“e xecute.cpp”#include"my.h"/**********复制剩余的数据(用于加法)****************/link copy1(link pre,link h){link l;l=(link)malloc(sizeof(item));l->num=h->num;l->e=h->e;l->next=NULL;pre->next=l;return h->next;}/**********复制剩余的数据(用于减法)****************/link copy2(link pre,link h){link l;l=(link)malloc(sizeof(item));l->num=-h->num;l->e=h->e;l->next=NULL;pre->next=l;return h->next;}/****搜索链表中是否已有相同次数的项,同次数项更新系数(用于乘法)****/int search(link h,int e,double num){h=h->next;while(h){if(h->e==e){h->num+=num;return 0;}h=h->next;}return 1;}/********将多项式按次数递增排序(用于乘法)********/void sort(link head){link pre,back,tp_pre,tp_back;for(pre=head,back=pre->next;back->next;pre=pre->next,back=pre->next)for(tp_pre=back,tp_back=tp_pre->next;tp_back;tp_pre=tp_pre->next,tp_back=tp_pre->next) if(tp_back->e<back->e){tp_pre->next=tp_back->next;pre->next=tp_back;tp_back->next=back;break;}}/****************两个多项式相加***************/link add(link h1,link h2){if(h1==NULL||h2==NULL||h1->num==0||h2->num==0){ printf("无多项式!\n");PAUSE;return NULL;}link head,l,pre;head=(link)malloc(sizeof(item));head->num=0;head->next=NULL;pre=head;for(h1=h1->next,h2=h2->next;h1||h2;){if(!h1){while(h2){h2=copy1(pre,h2);pre=pre->next;++head->num;}break;}if(!h2){while(h1){h1=copy1(pre,h1);pre=pre->next;++head->num;}break;}if(h1->e<h2->e){h1=copy1(pre,h1);pre=pre->next;++head->num;}else if(h1->e==h2->e){if(h1->num!=-h2->num){l=(link)malloc(sizeof(item));l->num=h1->num+h2->num;l->e=h1->e;l->next=NULL;pre->next=l;pre=pre->next;++head->num;}h1=h1->next;h2=h2->next;}else{h2=copy1(pre,h2);pre=pre->next;++head->num;}}printf("多项式相加完成!\n");PAUSE;CLS;return head;}/****************两个多项式相减***************/link subtract(link h1,link h2){if(h1==NULL||h2==NULL||h1->num==0||h2->num==0){ printf("无多项式!\n");PAUSE;return NULL;}link head,l,pre;head=(link)malloc(sizeof(item));head->num=0;head->next=NULL;pre=head;for(h1=h1->next,h2=h2->next;h1||h2;){if(!h1){while(h2){h2=copy2(pre,h2);pre=pre->next;++head->num;}break;}if(!h2){while(h1){h1=copy1(pre,h1);pre=pre->next;++head->num;}break;}if(h1->e<h2->e){h1=copy1(pre,h1);pre=pre->next;++head->num;}else if(h1->e==h2->e){if(h1->num!=h2->num){l=(link)malloc(sizeof(item));l->num=h1->num-h2->num;l->e=h1->e;l->next=NULL;pre->next=l;pre=pre->next;++head->num;}h1=h1->next;h2=h2->next;}else{h2=copy2(pre,h2);pre=pre->next;++head->num;}}printf("多项式相减完成!\n");PAUSE;CLS;return head;}/****************两个多项式相乘***************/link multiply(link h1,link h2){if(h1==NULL||h2==NULL||h1->num==0||h2->num==0){ printf("无多项式!\n");PAUSE;return NULL;}link head,end,temp,now;double num;int e;head=(link)malloc(sizeof(item));head->num=0;head->next=NULL;end=head;for(h1=h1->next;h1;h1=h1->next)for(now=h2->next;now;now=now->next){num=h1->num*now->num;e=h1->e+now->e;if(search(head,e,num)){temp=(link)malloc(sizeof(item));temp->num=num;temp->e=e;temp->next=NULL;end->next=temp;end=end->next;++head->num;}}sort(head);printf("多项式相乘完成!\n");PAUSE;CLS;return head;}“io.cpp”#include"my.h"/******************输入并按次数递增的顺序存储数据*********************/link input(void){link head,pre,back,l;double num;int e,flag;head=(link)malloc(sizeof(item));head->next=NULL;head->num=0;do{printf("请输入系数:");scanf("%lf",&num);printf("请输入指数:");scanf("%d",&e);CLS;if(!num) break;if(head->num==0){ //空链表时建立第一个节点l=(link)malloc(sizeof(item));l->num=num;l->e=e;l->next=NULL;head->next=l;++head->num;}else{ //保证存储数据时按次数递增的顺序存储flag=1;for(pre=head,back=pre->next;back;pre=pre->next,back=pre->next){if(e==back->e){ //链表中已有相同次数的项,修改系数即可back->num+=num;flag=0;break;}if(e<back->e){ //找到链表中第一个大于输入数据的节点,在此节点前插入新书局节点l=(link)malloc(sizeof(item));l->num=num;l->e=e;pre->next=l;l->next=back;++head->num;flag=0;break;}}if(flag){ //若新输入的数据次数比链表中的所有数据次数都大,则将此数据项接到链表末尾l=(link)malloc(sizeof(item));l->num=num;l->e=e;l->next=NULL;pre->next=l;++head->num;}}}while(1);return head;}/****************输出数据******************/void output(link h,char *title){printf("%s=",title);if(h==NULL||h->num==0){ //空链表时的输出printf("无多项式!\n");PAUSE;return;}while(h->next){h=h->next;if(h->num==1)if(h->e==0)printf("%g",h->num);elseprintf("x^%d",h->e);else if(h->e==0)printf("%g",h->num);elseprintf("%gx^%d",h->num,h->e);if(h->next&&h->next->num>0)putch('+');}putch('\n');PAUSE;}“m ain.cpp”#include"my.h"int main(void){link p,q,sum,sub,mul;p=q=sum=sub=mul=NULL;while(1){switch(menu()){case 1:if(judge(p,"P(x)")) p=input();break;case 2:if(judge(q,"Q(x)")) q=input();break;case 3:if(judge(sum,"P(x)+Q(x)")) sum=add(p,q);break;case 4:if(judge(sub,"P(x)-Q(x)")) sub=subtract(p,q);break;case 5:if(judge(mul,"P(x)*Q(x)")) mul=multiply(p,q);break;case 6:output(p,"P(x)");break;case 7:output(q,"Q(x)");break;case 8:output(sum,"P(x)+Q(x)");break;case 9:output(sub,"P(x)-Q(x)");break;case 10:output(mul,"P(x)*Q(x)");break;case 11:exit(0);}}}“menu.cpp”#include"my.h"static char string[11][20]={"1--createP(x)","2--create Q(x)","3--p(x)+Q(x)","4--P(x)-Q(x)","5--p(x)*Q(x)","6--printP(x)","7--printQ(x)","8--printP(x)+ Q(x)","9--print P(x)-Q(x)","10--print P(x)*Q(x)","11—Quit"};/*****************主菜单显示****************/int menu(void){int i;while(1){CLS;for(i=0;i<11;++i)puts(string[i]);printf("请选择:");scanf("%d",&i);if(i>=1&&i<=11){CLS;return i;}elseprintf("输入不合法,请重新输入!\n");PAUSE;}}/****************用于判断链表是否存在******************/int judge(link h,char *str){char ch;if(h==NULL||h->num==0)return 1;else{printf("%s is not Empty,Create %s again?\nInput Y or N:",str,str);while(1){ch=getch();if(ch=='y'||ch=='Y'){remove(h);CLS;return 1;}else if(ch=='n'||ch=='N')return 0;}CLS;}}/***************删除链表*******************/void remove(link head){link pre,back;for(pre=head,back=pre->next;back;pre=back,back=back->next) free(pre);free(pre);head=NULL;}实验四算术表达式求值“my.h”#pragma once#include<stdio.h>#include<stdlib.h>#include<conio.h>#include<math.h>#define CLS system("cls");#define PAUSE system("pause");#define N 50union Element{double num;char symbol;};typedef struct Node{Element data;Node *next;}Queue,*qNode,stackNode,*stack;typedef struct queueRecord{Queue *front;Queue *rear;}*qRecord;/********************************stack.cpp********************************/int isStackEmpty(stack top);stack creat_stack();void push(stack top,Element data); Element pop(stack top);Element top(stack top);/********************************queue.cpp********************************/int isQueueEmpty(qRecord queue); qRecord creat_queue();void Enqueue(qRecord queue,Element data); Element Dequeue(qRecord queue);/********************************input.cpp********************************/ void input(qRecord,stack);void output(qRecord);/********************************calculate.cpp********************************/ double calculate(qRecord,stack);/********************************menu.cpp********************************/int menu();void screen();“calculate.cpp”#include "my.h"double calculate(qRecord queue,stack stack){ Element a,b,temp;temp.num = 0;temp.symbol = NULL;while(!isQueueEmpty(queue)){temp = Dequeue(queue);if(temp.symbol == NULL)push(stack,temp);else{b = pop(stack);a = pop(stack);switch(temp.symbol){case '+': a.num+=b.num;push(stack,a);break;case '-': a.num-=b.num;push(stack,a);;break;case '*': a.num*=b.num;push(stack,a);;break;case '/': a.num/=b.num;push(stack,a);;break;}temp.num = 0;temp.symbol = NULL;}}return pop(stack).num;}“input.cpp”#include "my.h"int compare(Element a,Element b){ //a为栈顶的元素,b为新进入的元素int i,j;switch(a.symbol){case '+': i = 1;break;case '-': i = 1;break;case '*': i = 2;break;case '/': i = 2;break;case '(': i = 0;break;}switch(b.symbol){case '+': j = 1;break;case '-': j = 1;break;case '*': j = 2;break;case '/': j = 2;break;case '(': j = 3;break;case ')': j = 1;break;}if(i >= j)return 1;elsereturn 0;}void input(qRecord queue,stack stack){char ch;int j;Element temp;printf("请输入表达式:");temp.num = 0;for(ch = getchar();ch != '\n';ch = getchar()){if(ch-'0' >= 0 && ch-'0' <= 9){temp.num += (ch-'0')/10.0;temp.num *= 10;temp.symbol = NULL;continue;}if(ch == '.'){for(j = 0,ch = getchar();ch-'0' >= 0 && ch-'0' <= 9;ch = getchar()) temp.num += (ch-'0')/pow(10,++j);temp.symbol = NULL;Enqueue(queue,temp);temp.num = 0;if(ch == '\n')break;}if(ch == '+' || ch == '-' || ch == '*' || ch == '/' || ch == '(' || ch == ')'){ if(temp.num != 0){Enqueue(queue,temp);temp.num = 0;}temp.symbol = ch;while(!isStackEmpty(stack) && compare(top(stack),temp))Enqueue(queue,pop(stack));if(temp.symbol != ')')push(stack,temp);elsepop(stack);temp.num = 0;}}if(temp.num != 0 && temp.symbol == NULL)Enqueue(queue,temp);while(!isStackEmpty(stack))Enqueue(queue,pop(stack));}void output(qRecord queue){qNode q;if(isQueueEmpty(queue)){printf("表达式为空!\n");return;}printf("后缀表达式为:");for(q = queue->front;q != NULL;q = q->next) if(q->data.symbol == NULL)printf("%g ",q->data.num);elseprintf("%c ",q->data.symbol);putch('\n');}“main.cpp”#include "my.h"void main(){stack stack = creat_stack();qRecord queue = creat_queue();double result;screen();while(1){switch(menu()){case 1:input(queue,stack);PAUSE;break;case 2:output(queue);PAUSE;break;case 3:if(!isQueueEmpty(queue))result = calculate(queue,stack);printf("计算结果=%g\n",result);PAUSE;CLS;screen();break;case 4:exit(0);}}}“menu.cpp”#include "my.h"int menu(){int i;while(1){i = getch() - '0';if(i >= 1 && i <= 4)return i;}}void screen(){printf("1.输入表达式\n");printf("2.输出表达式\n");printf("3.得出结果\n");printf("4.退出\n");}“queue.cpp”#include "my.h"int isQueueEmpty(qRecord queue){if(queue->front == NULL)return 1;elsereturn 0;}qRecord creat_queue(){qRecord queue = (qRecord)malloc(sizeof(queueRecord));queue->front = queue->rear = NULL;return queue;}void Enqueue(qRecord queue,Element data){if(isQueueEmpty(queue)){queue->rear = (qNode)malloc(sizeof(Queue));queue->front = queue->rear;}else{queue->rear->next = (qNode)malloc(sizeof(Queue));queue->rear = queue->rear->next;}queue->rear->data = data;queue->rear->next = NULL;}Element Dequeue(qRecord queue){qNode temp = queue->front;Element data = temp->data;queue->front = queue->front->next;free(temp);return data;}“stack.cpp”#include "my.h"int isStackEmpty(stack top){if(top->next == NULL)return 1;elsereturn 0;}stack creat_stack(){stack st = (stack)malloc(sizeof(stackNode));st->next = NULL;return st;}void push(stack top,Element data){stack temp = (stack)malloc(sizeof(stackNode));temp->data = data;temp->next = top->next;top->next = temp;}Element pop(stack top){stack temp = top->next;Element data = temp->data;top->next = temp->next;free(temp);return data;}Element top(stack top){return top->next->data;}实验七哈夫曼编/译码器实验指导书“my.h”#pragma once#include<stdio.h>#include<stdlib.h>#include<conio.h>#include<math.h>“Huffman.cpp”#include<stdio.h> /* for size_t, printf() */#include<conio.h> /* for getch() */#include<ctype.h> /* for tolower() */#include<malloc.h> /* for malloc(), calloc(), free() */#include<string.h> /* for memmove(), strcpy() */#include<stdlib.h>/*树结构和全局结构指针*/#define NODENUM 26#define CLS system("cls");#define PAUSE system("pause");/*----------哈夫曼树结点结构-------------*/struct node{char ch;int weight;int parent;int lchild,rchild;} *ht; //指向哈夫曼树的存储空间的指针变量/*----------字符编码结点结构-------------*/struct HuffmanCoding{char ch;char coding[NODENUM];};/*--------哈夫曼树遍历时栈的结点结构------*/struct stacknode{int NodeLevel;int NodeElem;};/*---------------常量文件名---------------*/const char *TableFileName = "HfmTbl.txt"; //哈夫曼树数据文件const char *CodeFileName = "CodeFile.txt"; //字符编码数据文件const char *SourceFileName = "SrcText.txt"; //需编码的字符串文件const char *EnCodeFileName = "EnCodeFile.txt"; //编码数据文件const char *DecodeFileName = "DecodeFile.txt"; //译码字符文件/************************************************************/ /* 释放哈夫曼树数据空间函数*/ /************************************************************/ void free_ht(){if(ht != NULL){free(ht);ht = NULL;}}/************************************************************/ /* 从文件读取哈夫曼树数据函数*/ /************************************************************/ int ReadFromFile(){//int i;int m;FILE *fp;if((fp=fopen(TableFileName,"rb"))==NULL){printf("cannot open %s\n", TableFileName);getch();return 0;}fread(&m,sizeof(int),1,fp); //m为数据个数free_ht();ht=(struct node *)malloc(m*sizeof(struct node));fread(ht,sizeof(struct node),m,fp);fclose(fp);return m;}/************************************************************/ /* 吃掉无效的垃圾字符函数函数*/ /* 从键盘读字符数据时使用,避免读到无效字符*/ /************************************************************/ void EatCharsUntilNewLine(){while(getchar()!='\n') continue;}/************************************************************//* 选择权值最小的两个根结点函数*//************************************************************/void Select(struct node ht[],int n, int *s1,int *s2){int i,j;for(i = 0 ; i <= n && ht[i].parent != -1 ; ++i);for(j = i + 1 ; j < n ; ++j)if(ht[j].weight < ht[i].weight && ht[j].parent==-1)i = j;*s1 = i;for(i = 0 ; i <= n && (ht[i].parent != -1 || i==*s1); ++i);for(j = i + 1 ; j <= n ; ++j)if(ht[j].weight < ht[i].weight && j != *s1 && ht[j].parent==-1)i = j;*s2 = i;}/************************************************************//* 创建哈夫曼树和产生字符编码的函数*//************************************************************/void Initialization(){int i=0,n,m,j,f,s1,s2,start;char cd[NODENUM];struct HuffmanCoding code[NODENUM];FILE *fp;printf("输入字符总数n:");scanf("%d",&n);EatCharsUntilNewLine();m=2*n-1;ht=(struct node *)malloc(m*sizeof(struct node)); //申请哈夫曼树的存储空间//输入字符和权值for(i=0;i<n;i++){printf("请输入第%d个字符和权值:",i+1);scanf("%c",&ht[i].ch);scanf("%d",&ht[i].weight);ht[i].parent=ht[i].lchild=ht[i].rchild=-1;EatCharsUntilNewLine();}//剩余空间处理,初始化哈夫曼树for(i=n;i<m;i++){ht[i].ch='*';ht[i].weight=0;ht[i].parent=ht[i].lchild=ht[i].rchild=-1;}//建立哈夫曼树for(i=n;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].weight=ht[s1].weight+ht[s2].weight;}//把哈夫曼树的数据存储到文件中if((fp=fopen(TableFileName,"wb"))==NULL){printf("cannot open %s\n", TableFileName);getch();return;}fwrite(&m,sizeof(int),1,fp);fwrite(ht,sizeof(struct node),m,fp);fclose(fp);/*********************************************************/ /* 产生字符编码*/ /* 从叶结点开始,沿父结点上升,直到根结点,若沿*//* 父结点的左分支上升,则得编码字符“0”,若沿父结*/ /* 点的右分支上升,则得编码字符“1”*/ /*********************************************************///把字符编码数据存储到文件中if(!(fp=fopen(CodeFileName,"wb"))){printf("cannot open %s\n", CodeFileName);getch();return;}cd[n-1]=0;for(i=0;i<n;i++){start=n-1;for(j=i,f=ht[i].parent;f!=-1;j=f,f=ht[f].parent)if(ht[f].lchild==j)cd[--start]='0';elsecd[--start]='1';code[i].ch=ht[i].ch;strcpy(code[i].coding,&cd[start]);}fwrite(&n,sizeof(int),1,fp);fwrite(code,sizeof(struct HuffmanCoding),n,fp);fclose(fp);free_ht();printf("\nInitial successfule!\n");getch();}/************************************************************/ /* 哈夫曼编码的函数*/ /************************************************************/ void Encode(void){int i,j,n;char Encodestr[256];struct HuffmanCoding code[NODENUM];FILE *fp1, *fp2;//读字符编码数据fp1 = fopen(CodeFileName,"rb");fread(&n,sizeof(int),1,fp1);fread(code,sizeof(struct HuffmanCoding),n,fp1);//读需编码的字符串,把读入的文本串存储到文件中EatCharsUntilNewLine();printf("请输入要编码的字符串:");gets(Encodestr);fputs(Encodestr,fp1);fclose(fp1);//打开存储编码的数据文件,字符编码fp2=fopen(EnCodeFileName,"wb");printf("编码结果:\n");for(i=0; Encodestr[i]!='\0';++i)for(j=0;j<n;j++)if(Encodestr[i]==code[j].ch){printf("%s",code[j].coding);fwrite(code[j].coding,sizeof(code[j].coding),1,fp2);break;}fclose(fp2);printf("\n编码完成!\n");PAUSE;}/************************************************************/ /* 哈夫曼译码的函数*/ /************************************************************/ void Decode(){FILE *CFP, *TFP;char DeCodeStr[256];char ch;int f,m;m=ReadFromFile();//打开编码数据文件,打开存储译码的数据文件TFP=fopen(DecodeFileName,"wb");CFP=fopen(EnCodeFileName,"rb");//字符译码/********************************************************/ /* 方法:依次从编码数据文件中读取编码字符,并从*/ /* 哈夫曼树开始,若是数字字符“0”,则沿其左分*/ /* 支下降到孩子结点;若是数字字符“1”,则沿其*/ /* 右分支下降到孩子结点;如此反复,直到页结点,*/ /* 则输出页结点对应的字符到译码数据文件中,并*/ /* 显式。

相关文档
最新文档