实验四 排序程序设计
排序的实验报告册
一、实验目的1. 了解排序算法的基本原理和常用算法。
2. 掌握几种常用排序算法的代码实现。
3. 比较不同排序算法的性能，分析其优缺点。
4. 培养实验操作能力和分析问题能力。
二、实验环境1. 操作系统：Windows 102. 编程语言：Python3.73. 开发工具：PyCharm三、实验内容1. 实验一：冒泡排序2. 实验二：选择排序3. 实验三：插入排序4. 实验四：快速排序5. 实验五：归并排序四、实验步骤1. 实验一：冒泡排序（1）编写冒泡排序的Python代码。
（2）对一组随机生成的数据进行排序。
（3）观察排序过程，分析冒泡排序的优缺点。
2. 实验二：选择排序（1）编写选择排序的Python代码。
（2）对一组随机生成的数据进行排序。
（3）观察排序过程，分析选择排序的优缺点。
3. 实验三：插入排序（1）编写插入排序的Python代码。
（2）对一组随机生成的数据进行排序。
（3）观察排序过程，分析插入排序的优缺点。
4. 实验四：快速排序（1）编写快速排序的Python代码。
（2）对一组随机生成的数据进行排序。
（3）观察排序过程，分析快速排序的优缺点。
5. 实验五：归并排序（1）编写归并排序的Python代码。
（2）对一组随机生成的数据进行排序。
（3）观察排序过程，分析归并排序的优缺点。
五、实验结果与分析1. 实验一：冒泡排序（1）代码实现：```pythondef bubble_sort(arr):n = len(arr)for i in range(n):for j in range(0, n-i-1):if arr[j] > arr[j+1]:arr[j], arr[j+1] = arr[j+1], arr[j]```（2）排序过程：冒泡排序通过比较相邻两个元素的大小，将较大的元素向后移动，从而实现排序。
（3）优缺点分析：优点：易于理解，实现简单。
缺点：时间复杂度较高，对于大数据量排序效率较低。
排序的实验报告
排序的实验报告排序的实验报告引言：排序是计算机科学中非常重要的一个概念，它涉及到对一组数据按照一定规则进行重新排列的操作。
在计算机算法中，排序算法的效率直接影响到程序的运行速度和资源利用率。
为了深入了解各种排序算法的原理和性能，我们进行了一系列的排序实验。
实验一：冒泡排序冒泡排序是最简单的排序算法之一。
它的原理是通过相邻元素的比较和交换来实现排序。
我们编写了一个冒泡排序的算法，并使用Python语言进行实现。
实验中，我们分别对10、100、1000个随机生成的整数进行排序，并记录了排序所需的时间。
实验结果显示，随着数据规模的增加，冒泡排序的时间复杂度呈现出明显的增长趋势。
当数据规模为10时，排序所需的时间约为0.001秒；而当数据规模增加到1000时，排序所需的时间则增加到了1.5秒左右。
这说明冒泡排序的效率较低，对大规模数据的排序并不适用。
实验二：快速排序快速排序是一种常用的排序算法，它的核心思想是通过分治的策略将数据分成较小的子集，然后递归地对子集进行排序。
我们同样使用Python语言实现了快速排序算法，并对相同规模的数据进行了排序实验。
实验结果显示，快速排序的时间复杂度相对较低。
当数据规模为10时，排序所需的时间约为0.0005秒；而当数据规模增加到1000时，排序所需的时间仅为0.02秒左右。
这说明快速排序适用于大规模数据的排序，其效率较高。
实验三：归并排序归并排序是一种稳定的排序算法，它的原理是将待排序的数据分成若干个子序列，然后将子序列两两合并，直到最终得到有序的结果。
我们同样使用Python 语言实现了归并排序算法，并进行了相同规模数据的排序实验。
实验结果显示，归并排序的时间复杂度相对较低。
当数据规模为10时，排序所需的时间约为0.0008秒；而当数据规模增加到1000时，排序所需的时间仅为0.03秒左右。
这说明归并排序同样适用于大规模数据的排序，其效率较高。
讨论与结论：通过以上实验，我们可以得出以下结论：1. 冒泡排序虽然简单易懂，但对于大规模数据的排序效率较低，不适用于实际应用。
顺序程序设计(C语言实验报告)
仲恺农业工程学院实验报告纸信息学院（院、系）专业班C语言程序设计课实验目的：（1）掌握C语言中使用最多的一种语句——赋值语句的使用方法。
（2）掌握各种类型数据的输入输出方法。
实验内容与总结：1、验证性实验（1）键盘输入与屏幕输出练习问题1 要使下面程序的输出语句在屏幕上显示1, 2, 34，则从键盘输入的数据格式应为以下备选答案中的 D 。
#include <stdio.h>void main(){char a,b;int c;scanf("%c%c%d",&a,&b,&c);printf("%c,%c,%d\n",a,b,c);}A）1 2 34 B）1,2,34C）’1’,’2’,34D）12 34问题2 在与上面程序的键盘输入相同的情况下，要使上面程序的输出语句在屏幕上显示1 2 34，则应修改程序中的哪条语句？怎样修改？答：将“printf("%c,%c,%d\n",a,b,c);”改为“printf("%c %c %d\n",a,b,c);”问题3 要使上面程序的键盘输入数据格式为1,2,34，输出语句在屏幕上显示的结果也为1,2,34，则应修改程序中的哪条语句？怎样修改？答：将“scanf("%c%c%d",&a,&b,&c);”改为“scanf("%c,%c,%d",&a,&b,&c);”问题 4 要使上面程序的键盘输入数据格式为1,2,34，而输出语句在屏幕上显示的结果为'1', '2',34，则应修改程序中的哪些语句？怎样修改？答：将scanf("%c%c%d",&a,&b,&c);printf("%c,%c,%d\n",a,b,c);改为：scanf("%c,%c,%d",&a,&b,&c);printf("'%c','%c',%d\n",a,b,c);注意事项：printf和scanf函数使用是要注意“空格”、“’”、“，”的添加。
顺序结构程序设计实验报告
顺序结构程序设计实验报告顺序结构程序设计实验报告引言顺序结构是计算机程序设计中最基础的结构之一，它按照代码的书写顺序依次执行，没有条件判断或循环控制。
本实验旨在通过实践，加深对顺序结构的理解，并掌握其在程序设计中的应用。
实验目的通过编写程序，实现以下目标：1. 熟悉编程环境的搭建和基本操作；2. 掌握顺序结构的概念和使用方法；3. 运用顺序结构设计一个简单的计算器。
实验过程1. 编程环境搭建在实验开始前，我们先搭建编程环境。
选择一款编程软件，如Python或C++，并安装到计算机上。
打开软件后，创建一个新的项目或文件，以便开始编写代码。
2. 顺序结构的实现顺序结构的实现非常简单，只需按照代码的书写顺序编写即可。
在本实验中，我们将使用Python语言来实现顺序结构。
首先，我们定义两个变量a和b，用于存储用户输入的两个数字。
然后，我们使用input()函数来获取用户输入，并将其转换为整数类型。
代码如下：```a = int(input("请输入第一个数字："))b = int(input("请输入第二个数字："))```接下来，我们定义一个变量sum，用于存储两个数字的和。
通过将a和b相加，将结果赋值给sum变量。
代码如下：```sum = a + b```最后，我们使用print()函数将计算结果输出到屏幕上，让用户可以看到最终的结果。
代码如下：```print("两个数字的和为：", sum)```3. 编译和运行程序在编写完代码后，我们需要将其编译并运行。
编译的过程会将代码转换为计算机可以理解和执行的形式。
在Python中，不需要显式地进行编译，可以直接运行代码。
点击运行按钮或使用命令行工具运行程序，即可看到程序输出的结果。
根据用户输入的不同数字，程序将计算并输出它们的和。
实验结果经过编译和运行，我们成功实现了一个简单的计算器。
用户可以输入任意两个数字，程序会将它们相加并输出结果。
c语言程序设计实验指导答案
太原理工大学现代科技学院C语言程序设计课程实验报告专业班级学号姓名指导教师焦雄5.#include <stdio.h> void main(){int a=10,n=5;a+=a;printf("%d\n",a);a=10,a-=2;printf("%d\n",a);a=10,a*=2+3;printf("%d\n",a);a=10,a/=a+a;printf("%d\n",a);a=10,a%=(n%=2);printf("%d\n",a);a=10,a+=a-=a*=a;printf("%d\n",a); }遇到的问题和解决方法心得体会实验三简单程序、分支程序和循环程序设计实验名称实验目的和要求1.理解C语言程序的基本结构和实现基本结构的语句；2.熟练应用赋值、输入和输出语句；3.理解并掌握关系运算符、逻辑运算符及其表达式的使用；4.熟练掌握if语句、switch语句、while语句、do—while语句和for语句的用法；实验内容1.输入并运行第3章例3-3、例3-6中的程序，通过输出结果理解对应的格式说明。
2.输入并运行第3章例3-8、例3-10中的程序，注意输入数据的格式。
3.已知圆柱半径r=1.5，圆柱高h=3，编程求圆周长，圆面积和圆柱体积。
4.输入一百分制成绩，输出成绩等级A、B、C、D、E。
90分以上为A，80~89为B，70~79分为C，60~69分为D，60分以下为E。
要求程序能处理错误的输入数据。
5.利用公式：π/4=1-1/3+1/5-1/7+……，求π的近似值，直到最后一项的绝对值小于10-6为止。
（fabs(t)表示t的绝对值，1e-6=1*10-6）。
6.求100-200间所有素数。
7.输出三角形的九九乘法口诀表。
8.打印水仙花数。
水仙花数是指一个3位数，其各位数字立方和等于该数本身。
微机原理实验指导书(修改1023)
微机原理实验指导书华中科技大学计算机学院武汉豪申光电新技术有限公司目录微机原理实验 (3)第一章16位汇编语言编程验 (3)实验一系统认识实验 (3)实验二分支程序设计实验 (6)实验三循环程序设计实验 (9)实验四排序程序设计实验 (12)实验五子程序设计实验 (15)微机接口实验 (19)第一节并行接口实验(8255芯片实验) (19)实验一8255并行接口实验 (19)第二节定时/计数实验(8253芯片实验) (26)实验二音乐发声器接口实验 (26)第三节串行通信接口实验(8251芯片实验) (33)实验三 RS-232标准全双工查询方式异步串行通信实验 (34)第四节A/D D/A转换器接口实验 (42)实验四查询方式A/D转换器接口实验(ADC0809) (42)实验五 D/A函数波形发生器接口实验(DAC0832) (49)微机原理实验第一章16位汇编语言编程验实验一系统认识实验⑴实验目的掌握在MF平台中汇编程序的编写、调试方法。
⑵实验内容基本实验将存储区BUF1中的内容复制到BUF2中。
⑶实验步骤（一）方式1（Debug方式）1．在MF2KP环境下输入汇编程序，编译、连接，生成.exe文件。
2．启动调试程序（Debug）。
3．在程序的退出处设置断点，利用Add Watch命令查看BUF2中的内容是否正确。
（二）方式2（人-机交互方式）1．在MF2KP环境下输入汇编程序，编译、连接、运行。
2．按提示输入数据，在屏幕显示的结果中查看BUF1,2中的内容是否正确。
3．输入不同的字符串，可得到不同的结果。
⑷实验资源配置IBMPC微机，Win2000操作系统，MF2KP微机原理实验集成开发环境。
⑸实验软件的编程◇实验流程图如图1.1.1所示将存储区BUF1中的内容复制到BUF2中的程序主功能模块如图1.1.1中的虚线框中所示。
◇实验参考程序如下所示;*--------------------------------------------------* ;* Aexp1.asm(汇编语言编程认识实验) * ;* Copyright (c) 2002 by HUST * ;* 程序调试：在EXIT处设置断点，利用Add Watch命令 * ;* 查看BUF1和BUF2的内容是否正确 * ;*-------------------------------------------------* DATA SEGMENTBUF1 DB 'MASM HELLO WORLD'COUNT EQU $-BUF1BUF2 DB20DUP(?)DATA ENDSSTACK1 SEGMENT STACKDB20DUP(?)STACK1 ENDSCODE SEGMENTASSUME DS:DATA,SS:STACK1,CS:CODESTART:MOV AX,DATAMOV DS,AXMOV SI,OFFSET BUF1 ;建立源地址指针MOV DI,OFFSET BUF2 ;建立目标地址指针MOV CX,COUNT ;字节数送入CX寄存器L1: MOV AL,[SI] ; 取源数据一个字节送入AL中MOV [DI],AL;将源数据送入目标地址单元中INC SIINC DIDEC CXJNZ L1 ;判断是否传送完毕EXIT: MOV AH,4CHINT21HCODE ENDSEND START⑹实验要求◇按要求完成实验得出正确结果.◇试着自己写出人机对话方式的汇编程序.◇完成实验报告实验二分支程序设计实验⑴实验目的掌握分支程序的结构。
排序程序_实验报告
一、实验目的1. 理解并掌握几种常用的排序算法的基本原理。
2. 通过编程实现这些排序算法，并分析其性能。
3. 比较不同排序算法在时间复杂度和空间复杂度上的差异。
4. 理解排序算法在实际应用中的选择依据。
二、实验内容本次实验选择了以下几种排序算法进行实现和分析：冒泡排序、选择排序、插入排序、快速排序、归并排序和堆排序。
1. 冒泡排序2. 选择排序3. 插入排序4. 快速排序5. 归并排序6. 堆排序三、实验步骤1. 设计每种排序算法的函数，输入为待排序的数组，输出为排序后的数组。
2. 对每种排序算法进行性能测试，包括时间复杂度和空间复杂度。
3. 比较不同排序算法的效率，并分析其原因。
4. 编写测试用例，验证排序算法的正确性。
四、实验结果与分析1. 冒泡排序时间复杂度：O(n^2)空间复杂度：O(1)分析：冒泡排序是一种简单的排序算法，其基本思想是相邻元素两两比较，若逆序则交换，直到没有逆序对为止。
在最好情况下（已排序数组），时间复杂度为O(n)；在平均和最坏情况下（逆序数组），时间复杂度为O(n^2)。
2. 选择排序时间复杂度：O(n^2)空间复杂度：O(1)分析：选择排序的基本思想是遍历数组，在未排序部分中找到最小（或最大）的元素，将其与未排序部分的第一个元素交换，然后对剩余未排序部分重复该过程。
在最好、平均和最坏情况下，时间复杂度均为O(n^2)。
3. 插入排序时间复杂度：O(n^2)空间复杂度：O(1)分析：插入排序的基本思想是将数组分为已排序和未排序两部分，每次从未排序部分取出一个元素，将其插入到已排序部分的合适位置。
在最好情况下（已排序数组），时间复杂度为O(n)；在平均和最坏情况下（逆序数组），时间复杂度为O(n^2)。
4. 快速排序时间复杂度：O(nlogn)空间复杂度：O(logn)分析：快速排序是一种高效的排序算法，其基本思想是选取一个基准元素，将数组分为两个子数组，一个子数组中的元素都比基准元素小，另一个子数组中的元素都比基准元素大，然后递归地对两个子数组进行排序。
程序设计基础综合实验 综合实验四：学生电子通讯录管理系统—链表的应用实验报告
**大学**学院
程序设计基础综合实验 实验报告
综合实验四：学生电子通讯录管理系统—
一、实验内容：
问题描述：基于结构体链表，重新设计“综合实验二：学生电子通讯录管理系统——数组的 应用”里涉及的学生电子通讯录管理系统，要求重新设计后的系统应用以下功能。
二、实验源代码：
三、实验结果与分析（含测试数据、运行结果截图、分析和实验总结等）：
四、教师评语： 实验成绩：
教师：谢胜利
1．链表应用：输入功能。基于用户键盘输入，创建学生个人通讯信息链表，要求对用户输入 的个人信息进行有效性检查。
2．链表应用：输出功能。在上面设计的基础上，设计链表输出函数。 3．链表应用：查找功能。在上面设计的基础上，设计链表查找函数。要求可以根据 1）学号 查找、2）姓名查找、3）手机查找、4）性别查找、以及 5）生日范围查找等。然后，在显示器上 输出查找到的学生信息。 4．链表应用：插入功能。在上面设计的基础上，设计节点插入函数； 5．链表应用：删除功能。在上面设计的基础上，基于查找函数，设计节点删除函数，要求能 够根据查找的结果删除相应的节点。然后，在显示器上显示删除后的链表内容。 6．链表应用：排序功能。在上面设计的基础上，设计链表排序函数。要求可以根据 1）学号 排序、2）姓名排序、3）性别排序、4）手机排序、以及 5）生日排序等。然后，在显示器上，输 出排序后的通讯录。 7．链表应用：保存功能。在上面设计的基础上，设计链表保存到外部文件的函数； 8．链表应用：创建功能。在上面设计的基础上，设计基于外部文件创建链表的函数。
顺序程序设计实验报告
一、实验目的1. 理解顺序结构程序设计的基本概念和原理。
2. 掌握顺序结构程序设计的基本方法和步骤。
3. 通过实际编程，提高程序设计能力和逻辑思维能力。
二、实验环境1. 操作系统：Windows 102. 编译器：Visual Studio 20193. 编程语言：C++三、实验内容本次实验主要涉及顺序结构程序设计，包括以下内容：1. 输入输出操作2. 数据类型和变量3. 运算符和表达式4. 简单算法实现四、实验步骤1. 创建一个新的C++项目，命名为“顺序程序设计实验”。
2. 在项目中创建一个名为“main.cpp”的源文件。
3. 编写以下程序：```cpp#include <iostream>using namespace std;int main() {// 输入输出操作int a, b;cout << "请输入两个整数：" << endl;cin >> a >> b;cout << "第一个整数为：" << a << endl; cout << "第二个整数为：" << b << endl; // 数据类型和变量int sum = a + b;float average = (a + b) / 2.0;char grade = 'A';// 运算符和表达式int max = (a > b) ? a : b;int min = (a < b) ? a : b;// 简单算法实现if (sum > 10) {cout << "和大于10" << endl;} else {cout << "和小于等于10" << endl;}cout << "平均数为：" << average << endl; cout << "最大值为：" << max << endl;cout << "最小值为：" << min << endl;cout << "成绩为：" << grade << endl;return 0;}```4. 编译并运行程序，观察结果。
数据排序实验报告
一、实验目的1. 理解数据排序的基本概念和原理。
2. 掌握常见的数据排序算法，如冒泡排序、选择排序、插入排序、快速排序等。
3. 比较不同排序算法的效率，分析其适用场景。
4. 通过实验验证排序算法的正确性和性能。
二、实验环境1. 操作系统：Windows 102. 编程语言：Python3.73. 数据集：随机生成10000个整数，范围在1到100000之间。
三、实验内容1. 设计数据排序实验，包括冒泡排序、选择排序、插入排序、快速排序四种算法。
2. 实现四种排序算法的Python代码。
3. 比较四种排序算法的时间复杂度和空间复杂度。
4. 对随机生成的数据集进行排序，并记录每种算法的执行时间。
四、实验步骤1. 导入Python中的random模块，用于生成随机数据集。
2. 定义冒泡排序、选择排序、插入排序、快速排序四种算法的函数。
3. 生成随机数据集，并记录数据集的大小。
4. 分别调用四种排序算法对数据集进行排序，并记录每种算法的执行时间。
5. 分析四种排序算法的时间复杂度和空间复杂度，比较其效率。
五、实验结果与分析1. 数据集大小：10000个整数，范围在1到100000之间。
2. 冒泡排序：- 时间复杂度：O(n^2)- 空间复杂度：O(1)- 执行时间：约3.2秒3. 选择排序：- 时间复杂度：O(n^2)- 空间复杂度：O(1)- 执行时间：约3.5秒4. 插入排序：- 时间复杂度：O(n^2)- 空间复杂度：O(1)- 执行时间：约3.0秒5. 快速排序：- 时间复杂度：O(nlogn)- 空间复杂度：O(logn)- 执行时间：约0.8秒分析：从实验结果可以看出，快速排序在处理大量数据时具有更高的效率，其执行时间最短。
冒泡排序、选择排序和插入排序的时间复杂度均为O(n^2)，在数据量较大时效率较低。
快速排序的时间复杂度为O(nlogn)，在处理大量数据时具有较好的性能。
六、实验结论1. 掌握了数据排序的基本概念和原理。
实验四 队列的基本操作与应用实验报告
入队：Status EnQueue (LinkQueue &Q, QElemType e){ // 插入元素e为Q的新队尾元素p = (QueuePtr) malloc (sizeof (QNode)); //生成新结点if (!p) exit (OVERFLOW); //存储分配失败p->data = e; p->next = NULL; //插入队尾Q.rear->next = p;Q.rear = p; //修改队尾指针指向队尾return OK;}出队：Status DeQueue (LinkQueue &Q, QElemType &e){ // 若队列不空，则删除Q的队头元素，用e 返回其值if (Q.front == Q.rear) return ERROR; //判空p = Q.front->next; e = p->data; //用e返回队头元素值Q.front->next = p->next; //修改头指针始终指向队首元素if (Q.rear == p) Q.rear = Q.front; //特殊情况处理空队free (p); //释放队首结点return OK;}代码一：#include <stdio.h>#include <malloc.h>typedef char ElemType;typedef struct qnode{ElemType data;struct qnode *next;} QNode;typedef struct{QNode *front;QNode *rear;} LiQueue;void InitQueue(LiQueue *&q);void DestroyQueue(LiQueue *&q);bool QueueEmpty(LiQueue *q);void enQueue(LiQueue *&q, ElemType e);bool deQueue(LiQueue *&q, ElemType &e);void InitQueue(LiQueue *&q)//初始化队列{q = (LiQueue *)malloc(sizeof(LiQueue));q->front = q->rear = NULL;}void DestroyQueue(LiQueue *&q)//销毁队列{QNode *p = q->front, *r;//p指向队头数据节点if (p != NULL)//释放数据节点占用空间{r = p->next;while (r != NULL){free(p);p = r; r = p->next;}}free(p);free(q);//释放链队节点占用空间}bool QueueEmpty(LiQueue *q)//判断队列是否为空{return(q->rear == NULL);}void enQueue(LiQueue *&q, ElemType e)//进队{QNode *p;p = (QNode *)malloc(sizeof(QNode));p->data = e;p->next = NULL;if (q->rear == NULL)//若链队为空,则新节点是队首节点又是队尾节点q->front = q->rear = p;else{q->rear->next = p;//将*p节点链到队尾,并将rear指向它q->rear = p;}}bool deQueue(LiQueue *&q, ElemType &e)//出队{QNode *t;if (q->rear == NULL)//队列为空return false;t = q->front;//t指向第一个数据节点if (q->front == q->rear) //队列中只有一个节点时q->front = q->rear = NULL;else//队列中有多个节点时q->front = q->front->next;e = t->data;free(t);return true;}void main(){ElemType e;LiQueue *q;printf("链队的基本运算如下:\n");printf(" (1)初始化链队q\n");InitQueue(q);printf(" (2)依次进链队元素a,b,c\n");enQueue(q, 'a');enQueue(q, 'b');enQueue(q, 'c');printf(" (3)链队为%s\n", (QueueEmpty(q) ? "空" : "非空"));if (deQueue(q, e) == 0)printf("\t提示:队空,不能出队\n");elseprintf(" (4)出队一个元素%c\n", e);printf(" (5)依次进链队元素d,e,f\n");enQueue(q, 'd');enQueue(q, 'e');enQueue(q, 'f');printf(" (6)出链队序列:");while (!QueueEmpty(q)){deQueue(q, e);printf("%c ", e);}printf("\n");printf(" (7)释放链队\n");DestroyQueue(q);}代码二：#include <stdio.h>#include <malloc.h>typedef struct qnode{int data;struct qnode *next;} QNode;//链队节点类型typedef struct{QNode *front, *rear;} QuType;//链队类型void Destroyqueue(QuType *&qu)//释放链队{QNode *p, *q;p = qu->front;if (p != NULL)//若链队不空{q = p->next;while (q != NULL)//释放队中所有的节点{free(p);p = q;q = q->next;}free(p);}free(qu);//释放链队节点}void SeeDoctor(){int sel, flag = 1, find, no;QuType *qu;QNode *p;qu = (QuType *)malloc(sizeof(QuType));//创建空队qu->front = qu->rear = NULL;while (flag == 1) //循环执行{printf("1:排队2:就诊3:查看排队4.不再排队,余下依次就诊5:下班请选择:");scanf("%d", &sel);switch (sel){case 1:printf(" >>输入病历号:");do{scanf("%d", &no);find = 0;p = qu->front;while (p != NULL && !find){if (p->data == no)find = 1;elsep = p->next;}if (find)printf(" >>输入的病历号重复,重新输入:");} while (find == 1);p = (QNode *)malloc(sizeof(QNode));//创建节点p->data = no; p->next = NULL;if (qu->rear == NULL)//第一个病人排队qu->front = qu->rear = p;else{qu->rear->next = p; qu->rear = p;//将*p节点入队}break;case 2:if (qu->front == NULL)//队空printf(" >>没有排队的病人!\n");else//队不空{p = qu->front;printf(" >>病人%d就诊\n", p->data);if (qu->rear == p)//只有一个病人排队的情况qu->front = qu->rear = NULL;elsequ->front = p->next;free(p);}break;case 3:if (qu->front == NULL) //队空printf(" >>没有排列的病人!\n");else //队不空{p = qu->front;printf(" >>排队病人:");while (p != NULL){printf("%d ", p->data);p = p->next;}printf("\n");}一:二：总结体会：通过本次实验掌握了链式存储队列的进队和出队等基本操作，通过这些基本操作，我对队列问题有了更深的理解，能够正确理解队列问题及其使用。
《C程序设计》顺序结构程序设计实验报告
《C程序设计》顺序结构程序设计实验报告5. 编序C程序，实现将560分钟表示成**小时**分钟的形式输出。
6. 编序C程序，输入一个三位整数x(999=>x>=100)，将其分解出百位、十位、个位，并求出各位之和以及各位之积。
7. 编序C程序，要求从键盘任意输入一个3位数的正整数，输出其逆序数（例如输入123，输出321）。
三、实验过程与结论：（经调试正确的源程序（核心部分）和程序的运行结果）（三）编写程序1.#include<stdio.h>int main(){printf("*************\n Very good!\n*************\n");return 0;}2.#include<stdio.h>int main(){float a,b,c,s;a=38.9;b=27.2;c=2*(a+b);s=a*b;printf("周¨¹长¡è是º?%f,面?积y是º?%f\n",c,s);return 0;}3.#include<stdio.h>int main(){int a,b;printf("输º?入¨?两¢?个?整?数ºy：êo\n");scanf("%d %d",&a,&b);int x,y,z,m;x=a+b;y=a-b;z=a*b;m=a/b;printf("两¢?个?数ºy的Ì?和¨ª是º?%d,差?是º?%d,积y是º?%d,商¦¨¬是º?%d\n",x,y,z,m);return 0;}#include<stdio.h>#define PI 3.14int main(){float r,v;printf("请?输º?入¨?球¨°的Ì?半ã?径?:\n");scanf("%f",&r);v=4*PI*r*r*r/3;printf("球¨°的Ì?体¬?积y是º?%f\n",v);return 0;}5.#include<stdio.h>int main(){int a,b,c;a=560;b=a/60;c=a%60;printf("%d小?时º¡À，ê?%d分¤?钟¨®\n",b,c);return 0;6. #include<stdio.h>int main(){int a,b,c,d;int x,y;printf("请?输º?入¨?一°?个?三¨y位?数ºy：êo\n");scanf("%d",&a);b=a/100;c=a/10%10;d=a%10;x=b+c+d;y=b*c*d;printf("百㨴位?是º?%d,十º?位?是º?%d,个?位?是º?%d,个?位?之?和¨ª是º?%d,各¡Â位?之?积y 是º?%d\n",b,c,d,x,y);return 0;}7. #include<stdio.h>int main(){int a,b,c;int x,y;scanf("%d",&x);a=x/100;b=x/10%10;c=x%10;y=c*100+b*10+a;printf("%d\n",y);return 0;}四、实验总结：（实验中遇到的问题及解决方法，心得体会等）对于代码不熟悉，写代码速度慢，应在敲代码上花时间。
数据结构实验报告——排序
2008级数据结构实验报告实验名称：实验四排序学生姓名：班级：班内序号：学号：日期：2009年12月6日1．实验要求a. 实验目的通过实现下述实验内容，学习、实现、对比各种排序算法，掌握各种排序算法的优劣，以及各种算法使用的情况。
b. 实验内容使用简单数组实现下面各种排序算法，并进行比较。
排序算法：1、插入排序2、希尔排序3、冒泡排序4、快速排序5、简单选择排序6、堆排序（选作）7、归并排序（选作）8、基数排序（选作）9、其他2. 程序分析2.1 存储结构存储结构:顺序存储结构示意图如下:2.2 关键算法分析核心算法思想：1.利用教材讲述的基本算法思想，实现七种排序算法，统计其运行相关数据。
2.将七种排序函数入口地址作为函数指针数组，实现快速调用和统计。
使得程序代码可读性增、结构更加优化。
关键算法思想描述和实现：关键算法1：实现七种算法的基本排序功能。
1、插入排序：依次将待排序的序列中的每一个记录插入到先前排序好的序列中，直到全部记录排序完毕。
2、希尔排序：先将整个序列分割成若干个子列，分别在各个子列中运用直接插入排序，待整个序列基本有序时，再对全体记录进行一次直接插入排序。
3、冒泡排序：两两比较相邻记录的关键码，如果反序则交换，直到没有反序记录为止。
4、快速排序：首先选择一个基准，将记录分割为两部分，左支小于或等于基准，右支则大于基准，然后对两部分重复上述过程，直至整个序列排序完成。
5、选择排序：从待排序的记录序列中选择关键码最小（或最大）的记录并将它与序列中的第一个记录交换位置；然后从不包括第一个位置上的记录序列中选择关键码最小（或最大）的记录并将它与序列中的第二个记录交换位置；如此重复，直到序列中只剩下一个记录为止。
6、堆排序：通过建立大根堆或者小根堆，取出根节点，反复调整堆使之保持大根堆或者小根堆，直至最后序列有序。
7、归并排序：将若干个有序序列两两归并，直至所有待排序的记录都在一个有序序列为止。
顺序程序设计实验报告
顺序程序设计实验报告顺序程序设计实验报告引言顺序程序设计是计算机科学中的基础概念之一，也是初学者入门的重要环节。
本文将对顺序程序设计进行实验报告，通过实践探索该概念的应用和实际效果。
实验目的本次实验的目的是通过编写一段顺序程序，加深对顺序程序设计的理解，并掌握其基本语法和规则。
通过实践，我们将能够更好地理解程序的执行顺序和逻辑，提高编程能力。
实验过程首先，我们需要选择一个编程语言来实现顺序程序设计。
在本次实验中，我们选择了Python作为编程语言。
Python是一种简洁而强大的编程语言，非常适合初学者学习和实践。
接下来，我们需要定义一个问题或任务，以便编写程序。
在本次实验中，我们选择了一个简单的任务：计算圆的周长和面积。
这个问题非常适合顺序程序设计，因为它只涉及到顺序执行的计算过程。
在编写程序之前，我们需要了解圆的周长和面积的计算公式。
周长的计算公式是2πr，面积的计算公式是πr^2。
其中，π是一个常数，约等于3.14159，r是圆的半径。
接下来，我们可以开始编写程序了。
我们首先定义一个变量来表示圆的半径，然后使用周长和面积的计算公式来计算结果。
最后，我们将结果输出到屏幕上。
编写完成后，我们可以运行程序，观察结果是否正确。
如果结果与预期相符，则说明程序编写成功；如果结果不符，则需要检查代码逻辑和语法，进行调试和修改。
实验结果经过编写和测试，我们得到了正确的结果。
程序能够准确地计算圆的周长和面积，并将结果输出到屏幕上。
这证明了顺序程序设计的有效性和实用性。
实验总结通过本次实验，我们深入理解了顺序程序设计的概念和原理。
顺序程序设计是一种基础的编程思维方式，它能够帮助我们解决复杂的计算问题，并提高编程效率。
在实验过程中，我们学会了如何选择合适的编程语言来实现顺序程序设计。
Python作为一种简洁而强大的编程语言，非常适合初学者学习和实践。
此外，我们还学会了如何定义问题或任务，并使用适当的计算公式来解决问题。
《C语言程序设计实验》指导书(实验1~6)
《C语言程序设计实验》指导书（简明版）**大学软件学院**年**月实验一顺序结构程序设计（2学时）一、实验目的1、熟悉C编译环境、简单C程序结构及书写方式、以及C程序的编辑、编译、连接、运行、调试的步骤；2、掌握C语言的基本数据类型及其输入输出格式，以及输入输出函数的使用方法；3、掌握C语言的算术运算符（特别是自增、自减运算符）、赋值运算符、关系运算符、逻辑运算符、条件运算符、逗号运算符的使用；4、掌握C语言顺序结构程序的执行流程、设计方法，能够根据实际问题灵活使用顺序结构，画出程序的算法流程图，设计出逻辑合理、思路清晰、结果正确的顺序结构程序。
二、实验内容及要求1、实验内容包括8道题目，分为基本内容和选做内容两部分。
要求：（1）基本内容中的实验题目是必须要完成的，选做内容中的实验题目可以根据自己的情况选做或全做（越多越好，适当加分）；（2）在实验之前编写出基本内容、选做内容中的所有程序，实验前检查（视未完成情况适当扣分）；（3）对于设计型题目，要求画出程序流程图（传统流程图和N-S图）；（4）在上机实验过程中，注意总结和体会上机步骤（编辑、编译、连接、运行、调试、结果分析），注意培养观察、分析和排除编译错误、连接错误和程序逻辑错误的初步能力；（5）上机结束后，应按要求认真书写实验报告（格式见附件）。
2、基本内容（1）[验证型]编辑下列程序，然后进行编译、连接和运行，观察结果，并简要总结简单C程序的结构、书写格式以及上机过程；#include <stdio.h>int main( ){printf("Hello, world!\n");return 0;}（2）[验证型]通过运行下列程序，分析各种格式符的使用方法。
#include <stdio.h>int main( ){int a = 9, b = 2;float x = 32.8459, y = -792.451;char d = 'R';long n = 5461237;unsigned u = 65535;printf("%d,%d\n", a, b);printf("%3d,%3d\n", a, b);printf("%f,%f\n", x, y);printf("%-10f,%-10f\n", x, y);printf("%8.2f,%8.2\n", x, y);printf("%.4f,%.4f\n", x, y);printf("%3f,%3f\n", x, y);printf("%e,%10.2e\n", x, y);putchar(d);putchar('\n');printf("%c,%d,%o,%x\n", d, d, d, d);printf("%ld,%lo,%x\n", n, n, n);printf("%u,%o,%x,%d\n", u, u, u, u);return 0;}（3）[验证型]编辑下列程序，进行编译、连接和运行。
数据结构实验4 排序
实验4快速排序一、实验目的和要求1 在掌握各种排序方法的排序过程的基础上，完成快速排序算法程序设计。
2 能够对排序算法进行基本的复杂度分析。
二、实验内容排序就是把一组元素按照某个域的值的递增或递减的次序重新排列的过程。
快速排序在待排序记录序列中任取一个记录作为枢轴，以它作为比较的“基准”，将待排序划分为左右两个子序列，使行左边子序列中记录的关键字均小于等于枢轴，右边子序列中各记录的关键字都大于等于枢轴。
对所划分的两组分别重复上述过程，直到各个序列的记录个数为1时为止。
快速排序函数原型QuickSort(SeqList sq)。
设计一个算法，在顺序表存储结构上实现快速排序。
排序数据为学生的考试成绩单。
成绩单由学生的学号、姓名和成绩组成，设计一个程序对给定的n个学生的成绩单按照名次列打印出每个学生的名次、学号、姓名和成绩。
三、实验步骤1．输入待排序的记录2. 对自定义记录类型重载比较运算符3．排序1）并选择第一个记录作为pivotkey记录2）从high指向的记录开始,向前找到第一个关键字的值小于Pivotkey的记录,将其放到low指向的位置,low+13）.从low指向的记录开始,向后找到第一个关键字的值大于Pivotkey的记录,将其放到high指向的位置,high-14）重复2),3)，直到low=high，将枢轴记录放在low(high)指向的位置5）重复2),3),4)，直到整个记录有序为止6) 输出排序记录，完成比较。
4. 附加要求：不采用运算法重载的方式，而是定义compare函数指针，通过传给quicksort 函数指针，完成排序。
四、实验提示算法实现：#include "iostream.h"#define MaxSize 100typedef int DataType;class CRecord{public:int No;string name;int grade;}Typdef CRecord DataType;class SeqList{public:CRecord * data;int length;}//创建顺序表V oid SLCreat(SeqList & sq);{ CRecord x;length = 0;cout <<"请输入数据元素数”;cin>>sq.length;sq.data= new CRecord[sq.length];cout <<"请输入数据元素值: no, , name grade ";for(int i = 0; i < n; i++){cin >> sq.data[i].no>>sq .data[i].name>>sq. data[i]grade;}}//排序V oid Sort( SeqList & sq ){ SLCreat(sq);QuickSort(sq,0,sq.length);}//快速排序void QuickSort(SeqList & sq, int low, int high){ int pos;if(low < high){ pos = partition(sq,low, high);QuickSort(sq,low, pos-1);QuickSort(sq, pos+1, high);}}int partition(SeqList & list, int i, int j){ DataType pivotkey;pivotkey = list[i];while(i < j){ while(i < j&&list[j] >= pivotkey) --j;if(i < j) list[i++] = list[j];while(i < j&&list[i] <= pivotkey) ++i;if(i < j) list[j--] = list[i];}list[i] = pivotkeylreturn i;}//将顺序表显示在屏幕上void SLPrint(SeqList & sq){cout <<"快速排序结果: "’for(int i = 0; i <list.length; i++)cout<<i<<sq.data[i].no<<sq .data[i].name<<sq. data[i].grade<<endl;cout << endl;}void main( ){ SeqList myList;SLCreat(SeqList &mylist);Sort(mylist );SLPrint( );}。
实验四排序和检索程序设计报告
实验4 排序和检索程序设计一．实验目的：（1）掌握常用的ＤＯＳ输入输出系统功能调用。
（2）学习逻辑运算指令的用法。
(3) 掌握排序和检索程序的设计使用方法。
二．实验内容：编写程序1：将内存中10个无符号数（长度为2字节）由小到大排序。
编写程序2：在上述已排好序的数据区里查找某一个数。
若找到，显示其在数据区中的位置，否则显示‘N’字符。
编写主程序，通过调用程序1和程序2，实现排序和检索。
1、编译: c:\masm .asm2、链接: c:\link .obj3、调试: c:\debug .exe4、运行: c:\ .exe（1）1、编译: C:\masm 4-1.asmC:\masm>masm 4-1Microsoft (R) Macro Assembler Version 5.00Copyright (C) Microsoft Corp 1981-1985, 1987. All rights reserved.Object filename [4-1.OBJ]:Source listing [NUL.LST]:Cross-reference [NUL.CRF]:4-1.ASM(25): warning A4031: Operand types must match4-1.ASM(80): warning A4031: Operand types must match4-1.ASM(84): warning A4031: Operand types must match50158 + 415346 Bytes symbol space free3 Warning Errors0 Severe Errors2、链接: c:\link 4-1.objC:\masm>link 4-1Microsoft (R) Overlay Linker Version 3.65Copyright (C) Microsoft Corp 1983-1988. All rights reserved.Run File [4-1.EXE]:List File [NUL.MAP]:Libraries [.LIB]:3、调试: c:\debug 4-1.exe1）、先用命令U反汇编整个程序，查看每条指令的物理地址，其显示内容的含义为：内存地址指令代码反汇编的程序代码C:\masm>debug 4-1.exe-u1431代码段的首地址是：14341434:0003 8ED8 MOV DS,AX1434:0005 8D1E0000 LEA BX,[0000]1434:0009 B90A00 MOV CX,000A1434:000C E82800 CALL 00371434:000F BA1400 MOV DX,00141434:0012 B409 MOV AH,091434:0014 CD21 INT 211434:0016 B401 MOV AH,011434:0018 CD21 INT 211434:001A 240F AND AL,0F1434:001C A22300 MOV [0023],AL1434:001F B220 MOV DL,202）、从上一步结果中找到数据段的首地址142E，查看里面存储的数据，数据段从首地址1431中存储了：2,4,1,8,3,6,10,7,13,11 input the key:$-d 1431:00001431:0020 79 3A 24 05 00 00 00 00-00 00 00 00 00 00 00 00 y:$............. 1431:0030 B8 31 14 8E D8 8D 1E 00-00 B9 0A 00 E8 28 00 BA .1...........(.. 1431:0040 14 00 B4 09 CD 21 B4 01-CD 21 24 0F A2 23 00 B2 .....!...!$..#.. 1431:0050 20 B4 02 CD 21 8B 1E 00-00 B9 0A 00 8B 16 23 00 ...!.........#. 1431:0060 E8 28 00 B4 4C CD 21 50-33 C0 49 51 BB 00 00 8B .(..L.!P3.IQ.... 1431:0070 87 00 00 3B 87 02 00 76-08 87 87 02 00 89 87 00 ...;...v........ -.-3）、从反汇编地址中找到把数据段的首地址142E传给寄存器AX的指令地址:0005，用G 命令执行到地址0005 ，然后用T命令单步执行，看寄存器AX,DS,ES的内容的变化-g00051434:0005 8D1E0000 LEA BX,[0000] DS:0000=0002 -tAX=1431 BX=0000 CX=00F1 DX=0000 SP=0028 BP=0000 SI=0000 DI=0000DS=1431 ES=141E SS=142E CS=1434 IP=0009 NV UP EI PL NZ NA PO NC1434:0009 B90A00 MOV CX,000A-tAX=1431 BX=0000 CX=000A DX=0000 SP=0028 BP=0000 SI=0000 DI=0000DS=1431 ES=141E SS=142E CS=1434 IP=000C NV UP EI PL NZ NA PO NC1434:000C E82800 CALL 0037-tAX=1431 BX=0000 CX=000A DX=0000 SP=0026 BP=0000 SI=0000 DI=0000DS=1431 ES=141E SS=142E CS=1434 IP=0037 NV UP EI PL NZ NA PO NC1434:0037 50 PUSH AX-tAX=1431 BX=0000 CX=000A DX=0000 SP=0024 BP=0000 SI=0000 DI=0000DS=1431 ES=141E SS=142E CS=1434 IP=0038 NV UP EI PL NZ NA PO NC1434:0038 33C0 XOR AX,AX-tDS=1431 ES=141E SS=142E CS=1434 IP=003A NV UP EI PL ZR NA PE NC1434:003A 49 DEC CX-tAX=0000 BX=0000 CX=0009 DX=0000 SP=0024 BP=0000 SI=0000 DI=0000DS=1431 ES=141E SS=142E CS=1434 IP=003B NV UP EI PL NZ NA PE NC1434:003B 51 PUSH CX-tAX=0000 BX=0000 CX=0009 DX=0000 SP=0022 BP=0000 SI=0000 DI=0000DS=1431 ES=141E SS=142E CS=1434 IP=003C NV UP EI PL NZ NA PE NC1434:003C BB0000 MOV BX,0000-tAX=0000 BX=0000 CX=0009 DX=0000 SP=0022 BP=0000 SI=0000 DI=0000DS=1431 ES=141E SS=142E CS=1434 IP=003F NV UP EI PL NZ NA PE NC1434:003F 8B870000 MOV AX,[BX+0000] DS:0000=0002 -tDS=1431 ES=141E SS=142E CS=1434 IP=0043 NV UP EI PL NZ NA PE NC1434:0043 3B870200 CMP AX,[BX+0002] DS:0002=0004 -tAX=0002 BX=0000 CX=0009 DX=0000 SP=0022 BP=0000 SI=0000 DI=0000DS=1431 ES=141E SS=142E CS=1434 IP=0047 NV UP EI NG NZ AC PO CY1434:0047 7608 JBE 0051-4）然后直接G命令运行完毕。
最新实验四排序实验报告
最新实验四排序实验报告实验目的：1. 理解并掌握四种基本排序算法：冒泡排序、选择排序、插入排序和快速排序的工作原理及其性能特点。
2. 通过编程实践，加深对算法效率和适用场景的理解。
3. 培养分析问题和解决问题的能力，提高编程技巧。
实验环境：- 操作系统：Windows 10- 编程语言：Python 3.8- 开发工具：PyCharm实验内容：1. 编写冒泡排序算法实现对一组随机整数的排序。
2. 实现选择排序算法，并对同样的一组随机整数进行排序。
3. 完成插入排序算法的编码，并用相同的数据集进行测试。
4. 编写快速排序算法，并比较其与其他三种排序算法的效率。
5. 分析比较不同排序算法在最坏、平均和最好情况下的时间复杂度。
实验步骤：1. 首先，生成一组包含50个随机整数的数据集。
2. 对于冒泡排序，重复交换相邻的元素，如果前者大于后者，则进行交换。
3. 对于选择排序，遍历数组，找到最小（或最大）的元素，将其与第一个元素交换，然后从剩下的元素中继续寻找最小（或最大）的元素，依此类推。
4. 插入排序的实现是将数组分为已排序和未排序两部分，每次从未排序部分取出一个元素，插入到已排序部分的适当位置。
5. 快速排序通过选定一个基准值，将数组分为两部分，一部分的元素都小于基准值，另一部分的元素都大于基准值，然后递归地在两部分上重复这个过程。
6. 使用计时器分别记录四种排序算法的执行时间，并进行比较分析。
实验结果：- 冒泡排序：平均时间复杂度为O(n^2)，在实验数据集上的执行时间为X秒。
- 选择排序：平均时间复杂度为O(n^2)，在实验数据集上的执行时间为Y秒。
- 插入排序：平均时间复杂度为O(n^2)，在实验数据集上的执行时间为Z秒。
- 快速排序：平均时间复杂度为O(n log n)，在实验数据集上的执行时间为W秒。
实验结论：通过实验，我们发现快速排序在大多数情况下都比其他三种简单排序算法有更高的效率。
冒泡排序、选择排序和插入排序在最坏情况下的时间复杂度都较高，适合处理小规模数据集或者基本有序的数据。