堆排序实验报告

合集下载

堆栈模拟队列实验报告

堆栈模拟队列实验报告

一、实验目的通过本次实验,加深对堆栈和队列数据结构的理解,掌握堆栈的基本操作,并学会利用堆栈模拟队列的功能。

通过实验,培养学生的编程能力和问题解决能力。

二、实验内容1. 实现一个顺序堆栈,包括初始化、判断是否为空、入栈、出栈等基本操作。

2. 利用两个顺序堆栈实现队列的功能,包括入队、出队、判断队列是否为空等操作。

3. 通过实例验证模拟队列的正确性。

三、实验原理队列是一种先进先出(FIFO)的数据结构,而堆栈是一种后进先出(LIFO)的数据结构。

本实验通过两个堆栈来实现队列的功能。

当元素入队时,将其压入第一个堆栈(称为栈A);当元素出队时,先从栈A中依次弹出元素并压入第二个堆栈(称为栈B),直到弹出栈A中的第一个元素,即为队首元素。

四、实验步骤1. 定义堆栈的数据结构,包括堆栈的最大容量、当前元素个数、堆栈元素数组等。

2. 实现堆栈的基本操作,包括初始化、判断是否为空、入栈、出栈等。

3. 实现模拟队列的功能,包括入队、出队、判断队列是否为空等。

4. 编写主函数,创建两个堆栈,通过实例验证模拟队列的正确性。

五、实验代码```c#include <stdio.h>#include <stdlib.h>#define MAX_SIZE 100typedef struct {int data[MAX_SIZE];int top;} SeqStack;// 初始化堆栈void InitStack(SeqStack S) {S->top = -1;}// 判断堆栈是否为空int IsEmpty(SeqStack S) {return S->top == -1;}// 入栈int Push(SeqStack S, int x) {if (S->top == MAX_SIZE - 1) { return 0; // 堆栈已满}S->data[++S->top] = x;return 1;}// 出栈int Pop(SeqStack S, int x) {if (IsEmpty(S)) {return 0; // 堆栈为空}x = S->data[S->top--];return 1;}// 队列的入队操作void EnQueue(SeqStack S, SeqStack Q, int x) { Push(S, x);}// 队列的出队操作int DeQueue(SeqStack S, SeqStack Q, int x) { if (IsEmpty(Q)) {while (!IsEmpty(S)) {int temp;Pop(S, &temp);Push(Q, temp);}}if (IsEmpty(Q)) {return 0; // 队列为空}Pop(Q, x);return 1;}int main() {SeqStack S, Q;int x;InitStack(&S);InitStack(&Q);// 测试入队操作EnQueue(&S, &Q, 1);EnQueue(&S, &Q, 2);EnQueue(&S, &Q, 3);// 测试出队操作while (DeQueue(&S, &Q, &x)) {printf("%d ", x);}return 0;}```六、实验结果与分析1. 通过实例验证,模拟队列的入队和出队操作均正确实现了队列的先进先出特性。

实验报告模板

实验报告模板

合肥学院数学与物理系实验报告课程名称:算法分析实验项目:排序问题----堆排序实验类别:综合型学生姓名:学号:专业:实验时间:指导教师:邵桂伟实验成绩:一、实验目的:(此处用四号宋体,段落间距单倍行距。

段前段后0行)1.熟悉并使用VISUAL C++6.0编译软件;2.熟悉掌握堆这种数据结构的定义及各种操作,进而实现排序操作;3.掌握算法的空间复杂性和时间复杂性的概念,设计算法并分析算法的复杂性。

二、实验要求:1.使用VISUAL C++6.0编译软件;2.编辑并运行程序,得到递增序列;3.从算法的空间复杂性和时间复杂性分析该算法的复杂性。

三、实验内容:程序实现堆排序。

四、源程序及结果:(此处用四号宋体,段落间距单倍行距。

段前段后0行)1.源程序(小四,罗马字体)#include<stdio.h> #include<malloc.h> typedef struct node {int data;struct node *next; }linklist;linklist *creat() {int x,i,n;linklist *h,*p,*s,*q;h=(linklist*)malloc(sizeof(linklist));p=h;printf("\n请输入链表元素个数\n");scanf("%d",&n);printf("\n请输入链表元素\n");scanf("%d", &x);q=(linklist*)malloc(sizeof(linklist));q->data=x;h->next=q;p=q;for(i=1;i<n;i++){scanf("%d", &x);s=(linklist*)malloc(sizeof(linklist));s->data = x;if(x>=p->data){p->next = s;s->next=NULL;p=s;}else{q=h;while(q->next!=NULL&&x>=q->n ext->data)q=q->next;s->next=q->next;q->next=s;}}return h;}lout(linklist *p){while(p->next!=NULL){printf("%d->",p->data);p=p->next;}printf("%d\n",p->data);}void main(){int k;linklist *l,*p,*q;l=(linklist*)malloc(sizeof(linklist));l=creat();p=l->next;printf("未操作前链表元素为\n");lout(p);printf("请输入要插入的元素\n");scanf("%d", &k);q=(linklist*)malloc(sizeof(linklist));q->data=k;p=l;while(p->next!=NULL&&k>= p->next->data)p=p->next;q->next=p->next;p->next=q;printf("操作后链表元素为\n");p=l->next;lout(p);}2.运行结果(可以使用截图)3.程序复杂性分析(从时间和空间角度)学生签名:。

数组实验实验报告

数组实验实验报告

数组实验实验报告本文介绍的是一个数组实验的实验报告,介绍了实验的目的,实验内容、方法、结果以及分析,希望能为读者提供一些参考和帮助。

一、实验目的:1、了解数组的定义和基本概念;2、掌握数组元素的访问和操作;3、了解并掌握多维数组的定义和基本操作;4、掌握对数组进行排序的方法;5、学会用数组的方式实现一些常见的算法。

二、实验内容实验内容包括以下几个部分:1、数组定义和使用2、数组元素的访问和操作3、多维数组的定义和基本操作4、数组排序5、使用数组实现一些算法三、实验方法1、实验仪器和设备计算机、开发工具:Visual Studio2、实验步骤1)实现数组的定义和使用数组是一组有序的数据集合,可以是同类型,也可以是不同类型的数据。

可以通过定义数组可以简化程序的编写,提高程序的效率。

定义数组:通过关键字type或者var或者const,再加上数组名以及元素的类型等,来定义数组。

如下所示:type arrayName=arrayType[startIndex..endIndex] of dataType;(类型、数组名、数组元素的下标的范围、数据类型)vararrayNum:array[1..5] of integer;//定义5个元素的整数数组,并赋初值2)数组元素的访问和操作数组元素的访问:通过数组的下标来访问数组元素,下标从0开始,表示第一个元素,一次立1.如下所示:arrayName[index]:elementType; //数组名[下标]arrayNum[1]:=10;//将数组的第二个元素赋值成103)多维数组的定义和基本操作多维数组就是数组中包含了数组,具体的定义方式如下:typeMatrix=array[1..3,1..3] of integer;//定义一个3x3的整数矩阵varA,B: Matrix;A[1,1];//访问矩阵中的元素A[1,2]:=5;//给矩阵中的某个元素赋值4)数组排序排序是程序设计中最基本的算法之一,有很多种不同的排序算法。

排序实验报告_排序综合实验报告材料

排序实验报告_排序综合实验报告材料

班级
2*10^7
10 电信 1 班
10^8
操作系统
10^5
Microsoft Windows 7 旗舰版 (64 位/Service Pck 1)
正序
xxxxxxxxxxxxx
逆序
编译软件
直接插入
Visul C++ 6.0
(带监视哨〕
emil
C
609803959.
24.874
10^4
100.158
2*10^4
中选出键值最小的记录,与无序区第一个记录 R 交换;新的无序区为 R 到
各种排序试验结果:
R[n],从中再选出键值最小的记录,与无序区第一个记录 R 交换;类似, CPU
第 i 趟排序时 R 到 R[i-1]是有序区,无序区为 R[i]到 R[n],从中选出键
(英特尔)Intel(R) Core(TM) i5 CPU M 480 2.67GHz
〔1〕二路并归排序:开始时,将排序表 R 到 R[n]看成 n 个长度为 1
录,顺序放在已排好序的子序列的后面〔或最前〕,直到全部记录排序完 的有序子表,把这些子表两两并归,便得到 n/2 个有序的子表〔当 n 为奇
毕。
数时,并归后仍是有一个长度为 1 的子表〕;然后,再把这 n/2 个有序的
〔1〕直接选择排序:首先,全部记录组成初始无序区 R 到 R[n],从 子表两两并归,如此反复,直到最终得到一个程度为 n 的有序表为止。
指导老师: 胡圣荣
序与排序要求相反时就交换两者的位置,直到没有反序的记录为止。
日期: 20XX.12.15~20XX.1.5
〔1〕冒泡排序:设想排序表 R 到 R[n]垂直放置,将每个记录 R[i]看

数字整型算法实验报告(3篇)

数字整型算法实验报告(3篇)

第1篇一、实验目的1. 理解数字整型算法的基本原理和方法。

2. 掌握常用的数字整型算法,如整数乘法、除法、取余、排序等。

3. 培养算法设计与分析能力,提高编程实践能力。

二、实验内容1. 整数乘法算法2. 整数除法算法3. 整数取余算法4. 快速排序算法5. 堆排序算法三、实验原理1. 整数乘法算法:利用位运算,将两个整数进行逐位相乘,然后求和得到最终结果。

2. 整数除法算法:利用长除法原理,将除数逐步减去被除数的倍数,直到余数小于除数,此时商即为最终结果。

3. 整数取余算法:与整数除法类似,只需取除法的余数即可。

4. 快速排序算法:采用分治策略,将待排序的序列分为两部分,一部分大于等于基准值,另一部分小于基准值,然后递归地对这两部分进行排序。

5. 堆排序算法:利用堆这种数据结构,通过调整堆的性质来实现排序。

四、实验步骤1. 整数乘法算法实现```cint multiply(int a, int b) {int result = 0;while (b != 0) {if (b & 1) {result += a;}a <<= 1;b >>= 1;}return result;}```2. 整数除法算法实现```cint divide(int a, int b) {if (a == 0) return 0;int sign = (a > 0) ^ (b > 0) ? -1 : 1;long long dividend = abs((long long)a), divisor = abs((long long)b); long long quotient = 0;while (dividend >= divisor) {dividend -= divisor;quotient++;}return sign (int)quotient;}```3. 整数取余算法实现```cint remainder(int a, int b) {return a % b;}```4. 快速排序算法实现```cvoid quickSort(int arr[], int low, int high) { if (low < high) {int pivot = partition(arr, low, high); quickSort(arr, low, pivot - 1);quickSort(arr, pivot + 1, high);}}int partition(int arr[], int low, int high) { int pivot = arr[high];int i = low - 1;for (int j = low; j < high; j++) {if (arr[j] <= pivot) {i++;swap(&arr[i], &arr[j]);}}swap(&arr[i + 1], &arr[high]);return i + 1;}```5. 堆排序算法实现```cvoid heapify(int arr[], int n, int i) {int largest = i;int left = 2 i + 1;int right = 2 i + 2;if (left < n && arr[left] > arr[largest]) { largest = left;}if (right < n && arr[right] > arr[largest]) { largest = right;}if (largest != i) {swap(&arr[i], &arr[largest]);heapify(arr, n, largest);}}void heapSort(int arr[], int n) {for (int i = n / 2 - 1; i >= 0; i--) {heapify(arr, n, i);}for (int i = n - 1; i > 0; i--) {swap(&arr[0], &arr[i]);heapify(arr, i, 0);}}```五、实验结果与分析1. 整数乘法算法:通过位运算实现,效率较高,适用于大整数乘法运算。

常见算法设计实验报告(3篇)

常见算法设计实验报告(3篇)

第1篇一、实验目的通过本次实验,掌握常见算法的设计原理、实现方法以及性能分析。

通过实际编程,加深对算法的理解,提高编程能力,并学会运用算法解决实际问题。

二、实验内容本次实验选择了以下常见算法进行设计和实现:1. 排序算法:冒泡排序、选择排序、插入排序、快速排序、归并排序、堆排序。

2. 查找算法:顺序查找、二分查找。

3. 图算法:深度优先搜索(DFS)、广度优先搜索(BFS)、最小生成树(Prim算法、Kruskal算法)。

4. 动态规划算法:0-1背包问题。

三、实验原理1. 排序算法:排序算法的主要目的是将一组数据按照一定的顺序排列。

常见的排序算法包括冒泡排序、选择排序、插入排序、快速排序、归并排序和堆排序等。

2. 查找算法:查找算法用于在数据集中查找特定的元素。

常见的查找算法包括顺序查找和二分查找。

3. 图算法:图算法用于处理图结构的数据。

常见的图算法包括深度优先搜索(DFS)、广度优先搜索(BFS)、最小生成树(Prim算法、Kruskal算法)等。

4. 动态规划算法:动态规划算法是一种将复杂问题分解为子问题,通过求解子问题来求解原问题的算法。

常见的动态规划算法包括0-1背包问题。

四、实验过程1. 排序算法(1)冒泡排序:通过比较相邻元素,如果顺序错误则交换,重复此过程,直到没有需要交换的元素。

(2)选择排序:每次从剩余元素中选取最小(或最大)的元素,放到已排序序列的末尾。

(3)插入排序:将未排序的数据插入到已排序序列中适当的位置。

(4)快速排序:选择一个枢纽元素,将序列分为两部分,使左侧不大于枢纽,右侧不小于枢纽,然后递归地对两部分进行快速排序。

(5)归并排序:将序列分为两半,分别对两半进行归并排序,然后将排序好的两半合并。

(6)堆排序:将序列构建成最大堆,然后重复取出堆顶元素,并调整剩余元素,使剩余元素仍满足最大堆的性质。

2. 查找算法(1)顺序查找:从序列的第一个元素开始,依次比较,直到找到目标元素或遍历完整个序列。

排序的应用实验报告

排序的应用实验报告

排序的应用实验报告实验题目:排序的应用实验一、实验目的:1. 了解排序算法的基本原理和应用场景;2. 掌握常见的排序算法的实现方法;3. 熟悉排序算法的时间复杂度分析;4. 在实际应用中灵活运用排序算法。

二、实验原理:排序是将一组数据按照某个规则进行重新排列的过程,常见的排序算法有冒泡排序、选择排序、插入排序、归并排序、快速排序、堆排序等。

每种排序算法有其特点和适用场景,掌握不同排序算法的实现方法和时间复杂度对于实际应用非常重要。

三、实验内容及步骤:1. 冒泡排序实验:a) 随机生成一组整数数据;b) 利用冒泡排序算法对数据进行排序;c) 输出排序结果,并统计排序过程中的比较次数和交换次数。

2. 选择排序实验:a) 随机生成一组整数数据;b) 利用选择排序算法对数据进行排序;c) 输出排序结果,并统计排序过程中的比较次数和交换次数。

3. 插入排序实验:a) 随机生成一组整数数据;b) 利用插入排序算法对数据进行排序;c) 输出排序结果,并统计排序过程中的比较次数和移动次数。

4. 归并排序实验:a) 随机生成一组整数数据;b) 利用归并排序算法对数据进行排序;c) 输出排序结果。

5. 快速排序实验:a) 随机生成一组整数数据;b) 利用快速排序算法对数据进行排序;c) 输出排序结果。

四、实验结果及分析:1. 冒泡排序实验结果:随机生成的一组整数数据为:[5, 3, 8, 2, 6]排序过程中的比较次数为:10排序过程中的交换次数为:4排序结果为:[2, 3, 5, 6, 8]2. 选择排序实验结果:随机生成的一组整数数据为:[5, 3, 8, 2, 6] 排序过程中的比较次数为:10排序过程中的交换次数为:4排序结果为:[2, 3, 5, 6, 8]3. 插入排序实验结果:随机生成的一组整数数据为:[5, 3, 8, 2, 6] 排序过程中的比较次数为:10排序过程中的移动次数为:7排序结果为:[2, 3, 5, 6, 8]4. 归并排序实验结果:随机生成的一组整数数据为:[5, 3, 8, 2, 6] 排序结果为:[2, 3, 5, 6, 8]5. 快速排序实验结果:随机生成的一组整数数据为:[5, 3, 8, 2, 6]排序结果为:[2, 3, 5, 6, 8]五、实验总结:通过本次实验,我对常见的排序算法有了更深入的了解。

关于算法的实验报告(3篇)

关于算法的实验报告(3篇)

第1篇一、实验目的1. 理解快速排序算法的基本原理和实现方法。

2. 掌握快速排序算法的时间复杂度和空间复杂度分析。

3. 通过实验验证快速排序算法的效率。

4. 提高编程能力和算法设计能力。

二、实验环境1. 操作系统:Windows 102. 编程语言:C++3. 开发工具:Visual Studio 2019三、实验原理快速排序算法是一种分而治之的排序算法,其基本思想是:选取一个基准元素,将待排序序列分为两个子序列,其中一个子序列的所有元素均小于基准元素,另一个子序列的所有元素均大于基准元素,然后递归地对这两个子序列进行快速排序。

快速排序算法的时间复杂度主要取决于基准元素的选取和划分过程。

在平均情况下,快速排序的时间复杂度为O(nlogn),但在最坏情况下,时间复杂度会退化到O(n^2)。

四、实验内容1. 快速排序算法的代码实现2. 快速排序算法的时间复杂度分析3. 快速排序算法的效率验证五、实验步骤1. 设计快速排序算法的C++代码实现,包括以下功能:- 选取基准元素- 划分序列- 递归排序2. 编写主函数,用于生成随机数组和测试快速排序算法。

3. 分析快速排序算法的时间复杂度。

4. 对不同规模的数据集进行测试,验证快速排序算法的效率。

六、实验结果与分析1. 快速排序算法的代码实现```cppinclude <iostream>include <vector>include <cstdlib>include <ctime>using namespace std;// 生成随机数组void generateRandomArray(vector<int>& arr, int n) {srand((unsigned)time(0));for (int i = 0; i < n; ++i) {arr.push_back(rand() % 1000);}}// 快速排序void quickSort(vector<int>& arr, int left, int right) { if (left >= right) {return;}int i = left;int j = right;int pivot = arr[(left + right) / 2]; // 选取中间元素作为基准 while (i <= j) {while (arr[i] < pivot) {i++;}while (arr[j] > pivot) {j--;}if (i <= j) {swap(arr[i], arr[j]);i++;j--;}}quickSort(arr, left, j);quickSort(arr, i, right);}int main() {int n = 10000; // 测试数据规模vector<int> arr;generateRandomArray(arr, n);clock_t start = clock();quickSort(arr, 0, n - 1);clock_t end = clock();cout << "排序用时:" << double(end - start) / CLOCKS_PER_SEC << "秒" << endl;return 0;}```2. 快速排序算法的时间复杂度分析根据实验结果,快速排序算法在平均情况下的时间复杂度为O(nlogn),在最坏情况下的时间复杂度为O(n^2)。

西电算法导论上机实验报告

西电算法导论上机实验报告

算法导论上机实验报告册班级:xxxxxx学号:xxxxxxx 姓名:xxxx 教师:xxxxxx目录实验一排序算法 (1)题目一: (1)1、题目描述: (1)2、所用算法: (1)3、算法分析: (1)4、结果截图: (1)5、总结: (2)题目二: (3)1、题目描述: (3)2、所用算法: (3)3、算法分析: (3)4、结果截图: (3)5、总结: (4)题目三: (4)1、题目描述: (4)2、所用算法: (4)3、算法分析: (5)4、结果截图: (5)5、总结: (5)题目四: (6)1、题目描述: (6)3、算法分析: (6)4、结果截图: (6)5、总结: (7)实验二动态规划 (7)题目一: (7)1、题目描述: (7)2、所用策略: (7)3、算法分析: (7)4、结果截图: (8)5、总结: (8)题目二: (9)1、题目描述: (9)2、所用策略: (9)3、算法分析: (9)4、结果截图: (9)5、总结: (10)题目三: (10)1、题目描述: (10)2、所用策略: (10)3、算法分析: (10)4、结果截图: (11)题目四: (12)1、题目描述: (12)2、所用策略: (12)3、算法分析: (12)4、结果截图: (12)5、总结: (13)题目五: (13)1、题目描述: (13)2、所用策略: (13)3、算法分析: (13)4、结果截图: (14)5、总结: (14)实验三贪心算法 (14)题目一: (14)1、题目描述: (14)2、所用策略: (14)3、算法分析: (14)4、结果截图: (15)5、总结: (16)题目二: (16)1、题目描述: (16)3、算法分析: (16)4、结果截图: (17)5、总结: (17)题目三: (17)1、题目描述: (17)2、所用算法: (18)3、算法分析: (18)4、结果截图: (18)5、总结: (19)题目四: (19)1、题目描述: (19)2、所用算法: (19)3、算法分析: (19)实验四回溯法 (19)题目一: (19)1、题目描述: (20)2、所用策略: (20)3、算法分析: (20)题目二: (21)1、题目描述: (21)2、所用策略: (21)实验一排序算法题目一:1、题目描述:描述一个运行时间为θ(nlgn)的算法,给定n个整数的集合S和另一个整数x,该算法能确定S中是否存在两个其和刚好为x的元素。

堆排序每一趟的结果

堆排序每一趟的结果

堆排序每一趟的结果
原理
以最大堆为例,利用最大堆结构的特点:每个最大堆的根节点必然是数组中最大的元素,构建一次最大堆即可获取数组中最大的元素。

剔除最大元素后,反复构建余下数字为最大堆获取根元素最终保证数组有序。

堆排序流程
1.一趟堆排序
以数组int n[] = { 6, 5, 2, 7, 3, 9, 8 }为例:
步骤
一、构建最大堆:
从最后一个非叶子节点(计算公式为n.length/2-1,可自行验证)开始,从后往前进行调整构建,调整的规则是:若子节点大于父节点,则将子节点中较大的节点元素与父节点交换。

1.调整节点2(数组索引2),对比子节点9和8,再对比较大子节点9和父节点2,将9和2进行交换;
2.调整节点5(数组索引1),对比子节点7和3,将7和5进行交换;
3.调整节点6(素组索引0),对比子节点7和9,将6和9进行交换;
二、取出最大堆数组的第一位根元素与数组末位元素交换:
2.循环构建最大堆
根据上述构建最大堆的原理可以得出堆排序的完整过程
第1趟堆排序:
第2趟堆排序:
第3趟堆排序:
第4趟堆排序:
第5趟堆排序:
第6趟堆排序:。

排序算法实验报告

排序算法实验报告

数据结构实验报告八种排序算法实验报告一、实验内容编写关于八种排序算法的C语言程序,要求包含直接插入排序、希尔排序、简单项选择择排序、堆排序、冒泡排序、快速排序、归并排序和基数排序。

二、实验步骤各种内部排序算法的比较:1.八种排序算法的复杂度分析〔时间与空间〕。

2.八种排序算法的C语言编程实现。

3.八种排序算法的比较,包括比较次数、移动次数。

三、稳定性,时间复杂度和空间复杂度分析比较时间复杂度函数的情况:时间复杂度函数O(n)的增长情况所以对n较大的排序记录。

一般的选择都是时间复杂度为O(nlog2n)的排序方法。

时间复杂度来说:(1)平方阶(O(n2))排序各类简单排序:直接插入、直接选择和冒泡排序;(2)线性对数阶(O(nlog2n))排序快速排序、堆排序和归并排序;(3)O(n1+§))排序,§是介于0和1之间的常数。

希尔排序(4)线性阶(O(n))排序基数排序,此外还有桶、箱排序。

说明:当原表有序或基本有序时,直接插入排序和冒泡排序将大大减少比较次数和移动记录的次数,时间复杂度可降至O〔n〕;而快速排序则相反,当原表基本有序时,将蜕化为冒泡排序,时间复杂度提高为O〔n2〕;原表是否有序,对简单项选择择排序、堆排序、归并排序和基数排序的时间复杂度影响不大。

稳定性:排序算法的稳定性:假设待排序的序列中,存在多个具有相同关键字的记录,经过排序,这些记录的相对次序保持不变,则称该算法是稳定的;假设经排序后,记录的相对次序发生了改变,则称该算法是不稳定的。

稳定性的好处:排序算法如果是稳定的,那么从一个键上排序,然后再从另一个键上排序,第一个键排序的结果可以为第二个键排序所用。

基数排序就是这样,先按低位排序,逐次按高位排序,低位相同的元素其顺序再高位也相同时是不会改变的。

另外,如果排序算法稳定,可以防止多余的比较;稳定的排序算法:冒泡排序、插入排序、归并排序和基数排序不是稳定的排序算法:选择排序、快速排序、希尔排序、堆排序四、设计细节排序有内部排序和外部排序,内部排序是数据记录在内存中进行排序,而外部排序是因排序的数据很大,一次不能容纳全部的排序记录,在排序过程中需要访问外存。

排序实验报告

排序实验报告

实验五排序实验目的: 掌握几种排序的思想及算法问题分析:(一)直接插入排序1. 排序思想将待排序的记录Ri,插入到已排好序的记录表R1, R2 ,…., Ri-1中,得到一个新的、记录数增加1的有序表。

直到所有的记录都插入完为止。

设待排序的记录顺序存放在数组R[1…n]中,在排序的某一时刻,将记录序列分成两部分:◆R[1…i-1]:已排好序的有序部分;◆R[i…n]:未排好序的无序部分。

显然,在刚开始排序时,R[1]是已经排好序的。

2 . 算法实现void straight_insert_sort(Sqlist R){ int i, j ;for (i=2; i<=n; i++){ R[0]=R[i]; j=i-1; /*设置哨兵*/while( LT(R[0].key, R[j].key) ){ R[j+1]=R[j];j--;} /* 查找插入位置*/R[j+1]=R[0]; /* 插入到相应位置*/}}(二)希尔排序1. 排序思想①先取一个正整数d1(d1<n)作为第一个增量,将全部n个记录分成d1组,把所有相隔d1的记录放在一组中,即对于每个k(k=1, 2, … d1),R[k], R[d1+k], R[2d1+k] , …分在同一组中,在各组内进行直接插入排序。

这样一次分组和排序过程称为一趟希尔排序;②取新的增量d2<d1,重复①的分组和排序操作;直至所取的增量di=1为止,即所有记录放进一个组中排序为止。

2. 算法实现先给出一趟希尔排序的算法,类似直接插入排序。

void shell_pass(Sqlist R, int d)/* 对顺序表L进行一趟希尔排序, 增量为d */{ int j, k ;for (j=d+1; j<=n; j++){ R[0]=R[j] ; /* 设置监视哨兵*/k=j-d ;while (k>0&&LT(R[0].key, R[k].key) ){ R[k+d]=R[k] ; k=k-d ; }R[k+d]=R[0] ;}}然后在根据增量数组dk进行希尔排序。

山东大学数据结构实验报告四

山东大学数据结构实验报告四

山东大学数据结构实验报告四实验报告四:堆排序算法的设计与实现一、引言堆排序是一种基于二叉堆的排序算法,其具有时间复杂度为O(nlogn)的特点,适用于大规模数据的排序。

本实验旨在通过设计与实现堆排序算法,掌握堆排序的原理和实现过程,并分析其时间复杂度和空间复杂度。

二、实验目的1. 理解堆排序的基本原理;2. 掌握堆排序算法的实现过程;3. 分析堆排序算法的时间复杂度和空间复杂度。

三、实验内容1. 设计堆排序算法的流程;2. 根据设计的流程,编写堆排序算法的代码;3. 使用随机生成的数据进行测试,并记录排序结果;4. 分析堆排序的时间复杂度和空间复杂度。

四、实验步骤1. 设计堆排序算法的流程:1.1 创建一个最大堆(Max Heap);1.2 将堆顶元素与最后一个元素交换;1.3 对剩余元素进行堆调整,使其满足最大堆的性质;1.4 重复步骤2和3,直到所有元素排序完成。

2. 根据设计的流程,编写堆排序算法的代码:```java// 堆排序算法public class HeapSort {public static void sort(int[] arr) {int n = arr.length;// 构建最大堆for (int i = n / 2 - 1; i >= 0; i--)heapify(arr, n, i);// 依次将堆顶元素与最后一个元素交换,并重新调整堆 for (int i = n - 1; i >= 0; i--) {int temp = arr[0];arr[0] = arr[i];arr[i] = temp;heapify(arr, i, 0);}}// 调整堆public static void heapify(int[] arr, int n, int i) {int largest = i; // 最大元素的索引int left = 2 * i + 1; // 左子节点的索引int right = 2 * i + 2; // 右子节点的索引// 如果左子节点比最大元素大,则更新最大元素的索引if (left < n && arr[left] > arr[largest])largest = left;// 如果右子节点比最大元素大,则更新最大元素的索引if (right < n && arr[right] > arr[largest])largest = right;// 如果最大元素的索引不是当前节点,则交换当前节点和最大元素,并继续调整堆if (largest != i) {int swap = arr[i];arr[i] = arr[largest];arr[largest] = swap;heapify(arr, n, largest);}}}```3. 使用随机生成的数据进行测试,并记录排序结果:```javapublic class Main {public static void main(String[] args) {int[] arr = generateRandomData(100); // 生成100个随机数 System.out.println("排序前:");printArray(arr);HeapSort.sort(arr); // 使用堆排序算法进行排序System.out.println("排序后:");printArray(arr);}// 生成随机数据public static int[] generateRandomData(int n) {int[] arr = new int[n];Random random = new Random();for (int i = 0; i < n; i++) {arr[i] = random.nextInt(1000);}return arr;}// 打印数组public static void printArray(int[] arr) {for (int i : arr) {System.out.print(i + " ");}System.out.println();}}```排序前:567 245 789 123 456 789 234 567 890 123 ...排序后:1 2 3 4 5 6 7 8 9 10 ...4. 分析堆排序的时间复杂度和空间复杂度:- 时间复杂度:堆排序的建堆过程的时间复杂度为O(n),每次调整堆的时间复杂度为O(logn),共需要调整n-1次。

排序程序_实验报告

排序程序_实验报告

一、实验目的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)分析:快速排序是一种高效的排序算法,其基本思想是选取一个基准元素,将数组分为两个子数组,一个子数组中的元素都比基准元素小,另一个子数组中的元素都比基准元素大,然后递归地对两个子数组进行排序。

排序实验报告的结果总结(3篇)

排序实验报告的结果总结(3篇)

第1篇一、实验背景随着计算机科学和信息技术的发展,排序算法在数据处理的领域中扮演着至关重要的角色。

本实验旨在通过对比几种常见的排序算法,分析它们的性能差异,为实际应用中选择合适的排序算法提供参考。

二、实验目的1. 熟悉几种常见排序算法的基本原理和实现方法。

2. 分析不同排序算法的时间复杂度和空间复杂度。

3. 比较不同排序算法在不同数据规模下的性能差异。

4. 为实际应用提供选择排序算法的依据。

三、实验方法1. 选择实验数据:随机生成一组包含10000个整数的数组,分别用于测试不同排序算法的性能。

2. 实现排序算法:分别实现冒泡排序、选择排序、插入排序、快速排序、归并排序、堆排序等常见排序算法。

3. 性能测试:分别对每组实验数据进行排序,记录每种排序算法的运行时间。

4. 数据分析:对比不同排序算法的时间复杂度和空间复杂度,分析其性能差异。

四、实验结果1. 冒泡排序冒泡排序的时间复杂度为O(n^2),空间复杂度为O(1)。

在测试数据规模为10000时,冒泡排序的运行时间为234.5秒。

2. 选择排序选择排序的时间复杂度为O(n^2),空间复杂度为O(1)。

在测试数据规模为10000时,选择排序的运行时间为237.1秒。

3. 插入排序插入排序的时间复杂度为O(n^2),空间复杂度为O(1)。

在测试数据规模为10000时,插入排序的运行时间为239.8秒。

4. 快速排序快速排序的平均时间复杂度为O(nlogn),空间复杂度为O(logn)。

在测试数据规模为10000时,快速排序的运行时间为18.5秒。

5. 归并排序归并排序的时间复杂度为O(nlogn),空间复杂度为O(n)。

在测试数据规模为10000时,归并排序的运行时间为20.3秒。

6. 堆排序堆排序的时间复杂度为O(nlogn),空间复杂度为O(1)。

在测试数据规模为10000时,堆排序的运行时间为19.7秒。

五、结果分析1. 时间复杂度方面:快速排序、归并排序和堆排序的平均时间复杂度均为O(nlogn),优于冒泡排序、选择排序和插入排序的O(n^2)时间复杂度。

算法实验报告_排序

算法实验报告_排序

一、实验背景排序是计算机科学中常见的基本操作,对于数据结构的学习和运用具有重要意义。

本实验旨在通过实现几种常见的排序算法,比较它们的性能,并分析它们的适用场景。

二、实验目的1. 熟悉几种常见的排序算法。

2. 比较不同排序算法的执行时间和稳定性。

3. 分析不同排序算法的适用场景。

三、实验内容1. 选择排序算法:冒泡排序、选择排序、插入排序、快速排序、归并排序、堆排序。

2. 实现排序算法。

3. 生成随机数组和有序数组,分别对两种数组进行排序。

4. 记录每种排序算法的执行时间和稳定性。

5. 分析不同排序算法的性能。

四、实验步骤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)选择排序选择排序是一种简单直观的排序算法。

它的工作原理是:首先在未排序序列中找到最小(大)元素,存放到排序序列的起始位置,然后,再从剩余未排序元素中继续寻找最小(大)元素,然后放到已排序序列的末尾。

以此类推,直到所有元素均排序完毕。

```pythondef selection_sort(arr):n = len(arr)for i in range(n):min_idx = ifor j in range(i+1, n):if arr[min_idx] > arr[j]:min_idx = jarr[i], arr[min_idx] = arr[min_idx], arr[i]```(3)插入排序插入排序是一种简单直观的排序算法。

它的工作原理是通过构建有序序列,对于未排序数据,在已排序序列中从后向前扫描,找到相应位置并插入。

数据结构中查找和排序算法实验报告

数据结构中查找和排序算法实验报告
}
mergesort(ListType &r,ListType &r1,int s,int t)
{
if (s==t)
r1[s]=r[s];
else
{
mergesort(r,r2,s,s+t/2);
mergesort(r,r2,s+t/2+1,t);
merge(r2,s,s+t/2,t,r1);
}
}
4.堆排序算法描述如下:
堆排序要解决两个问题:1、如何由一个无序序列建成一个堆?2、如何在输出堆顶元素之后,调整剩余元素成为一个新的堆?
问题2的解决方法:
四.实验数据与清单:
1.折半查找算法描述如下:
int Search_Bin(SSTable ST,KeyType key)
low=1;high=ST.length;
while(low<=high){
sift(ListType &r,int k,int m)
{
i=k;j=2*i;x=r[k].key;finished=FALSE;
t=r[k];
while((j<=m)&&(!finished))
{
if ((j<m)&&(r[j].key>r[j+1].key)) j++;
if (x<=r[j].key)
通过本次实验,我了发现书本上的知识和老师的讲解都能慢慢理解。但是做实验的时候,需要我把理论变为上机调试,这无疑是最难的部分,有时候我想不到合适的算法去解决问题,就请教同学,上网搜索,逐渐纠正了自己的错误。这次的程序设计对我的编程设计思维有很大的提高,以前我很不懂这门课,觉得它很难,但是现在明白了一些代码的应用,明白了每个程序都有相似的特点,通用的结构,也学会了静下心来写程序。我以后还要把没学好的知识点补齐,克服编程过程中的难关,打实基础,向更深入的层次发展。

排序C++程序实验报告

排序C++程序实验报告

数据结构实验报告实验名称:实验四——排序学生姓名:班级:班内序号:学号:日期:1.实验要求使用简单数组实现下面各种排序算法,并进行比较。

排序算法:1、插入排序2、希尔排序3、冒泡排序4、快速排序5、简单选择排序6、堆排序(选作)7、归并排序(选作)8、基数排序(选作)9、其他要求:1、测试数据分成三类:正序、逆序、随机数据2、对于这三类数据,比较上述排序算法中关键字的比较次数和移动次数(其中关键字交换计为3次移动)。

3、对于这三类数据,比较上述排序算法中不同算法的执行时间,精确到微秒(选作)4、对2和3的结果进行分析,验证上述各种算法的时间复杂度编写测试main()函数测试线性表的正确性。

2. 程序分析插入排序类似于玩纸牌时整理手中纸牌的过程,它的基本方法是寻找一个指定元素在待排序元素中的位置,然后插入。

直接插入排序的基本思想可以这样描述:每次讲一个待排序的元素按其关键码的大小插入到一个已经排序好的有序序列中,直到全部元素排序好。

元素个数为1时必然有序,这就是初始有序序列;可以采用顺序查找的方法查找插入点,为了提高时间效率,在顺序查找过程中边查找边后移的策略完成一趟插入。

希尔排序又称“缩小增量排序”,是对直接插入排序的一种改进,它利用了直接插入的两个特点:1.基本有序的序列,直接插入最快;2.记录个数很少的无序序列,直接插入也很快。

希尔排序的基本思想为:将待排序的元素集分成多个子集,分别对这些子集进行直接插入排序,待整个序列基本有序时,再对元素进行一次直接插入排序。

冒泡排序的基本思想是:两两比较相邻的元素,如果反序,则交换位置,直到没有反序的元素为止。

具体的排序过程是:将整个待排序元素划分成有序区和无序区,初始状态有序区为空,无序区包括所有待排序的元素;对无序区从前向后依次将相邻元素的关键码进行比较,若反序则交换,从而使得关键码小的元素向前移,关键码大的元素向后移;重复执行前一个步骤,直到无序区中没有反序的元素。

数据结构-堆栈和队列实验报告

数据结构-堆栈和队列实验报告

数据结构-堆栈和队列实验报告数据结构堆栈和队列实验报告一、实验目的本次实验的主要目的是深入理解和掌握数据结构中的堆栈和队列的基本概念、操作原理以及实际应用。

通过实际编程实现堆栈和队列的相关操作,加深对其特性的认识,提高编程能力和解决问题的能力。

二、实验环境本次实验使用的编程语言为 Python,开发工具为 PyCharm。

三、实验原理(一)堆栈(Stack)堆栈是一种特殊的线性表,其操作遵循“后进先出”(Last In First Out,LIFO)的原则。

可以将堆栈想象成一个只能从一端进行操作的容器,新元素总是被添加到这一端(称为栈顶),而取出元素也只能从栈顶进行。

堆栈的基本操作包括:1、`push`:将元素压入堆栈。

2、`pop`:弹出堆栈顶部的元素。

3、`peek`:查看堆栈顶部的元素,但不弹出。

(二)队列(Queue)队列是另一种特殊的线性表,其操作遵循“先进先出”(First In First Out,FIFO)的原则。

可以将队列想象成一个排队的队伍,新元素在队尾加入,而取出元素从队首进行。

队列的基本操作包括:1、`enqueue`:将元素加入队列的尾部。

2、`dequeue`:取出并删除队列头部的元素。

3、`front`:查看队列头部的元素,但不取出。

四、实验内容(一)堆栈的实现```pythonclass Stack:def __init__(self):selfitems =def push(self, item):selfitemsappend(item)def pop(self):if not selfis_empty():return selfitemspop()else:return "Stack is empty" def peek(self):if not selfis_empty():return selfitems-1else:return "Stack is empty" def is_empty(self):return len(selfitems) == 0 def size(self):return len(selfitems)```(二)队列的实现```pythonclass Queue:def __init__(self):selfitems =def enqueue(self, item):selfitemsappend(item)def dequeue(self):if not selfis_empty():return selfitemspop(0) else:return "Queue is empty" def front(self):if not selfis_empty():return selfitems0else:return "Queue is empty" def is_empty(self):return len(selfitems) == 0 def size(self):return len(selfitems)```(三)应用实例1、利用堆栈实现括号匹配的验证```pythondef is_balanced_parentheses(exp):stack = Stack()for char in exp:if char in '({':stackpush(char)elif char in ')}':if stackis_empty():return Falsetop = stackpop()if (char ==')' and top!='(') or (char =='}' and top!='{') or (char =='' and top!=''):return Falsereturn stackis_empty()```2、利用队列实现打印杨辉三角的前 n 行```pythondef print_yanghui_triangle(n):queue = Queue()queueenqueue(1)print(1)for i in range(1, n):prev_row =for _ in range(i + 1):num = queuedequeue()prev_rowappend(num)print(num, end="")if _< i:new_num = prev_row_ +(prev_row_ 1 if _> 0 else 0) queueenqueue(new_num)print()```五、实验结果与分析(一)堆栈实验结果对于括号匹配的验证,输入`"((()))"`,输出为`True`,表示括号匹配正确;输入`"((())"`,输出为`False`,表示括号匹配错误。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
Heap_Sort(n);
printf("输出排好序后的A中的元素");
for(i=1;i<=n;i++)
printf("%3d",R[i]);
printf("\n");
}
七、程序使用说明及测试结果
1、程序使用说明
(1)本程序的运行环境为VC6.0。
(2)进入演示程序后即显示提示信息:
请输入数组A元素的个数:回车;
printf("请输入数组A元素的个数:");
scanf("%d",&n);
if(n<=0||n>MAX)
{
printf("请重新输入n");
}
printf("请输入数组A的元素值\n");
for(i=1;i<=n;i++)
scanf("%d",&R[i]);
Heap_Sort(n);
printf("输出排好序后的A中的元素");
{
if(R[j]<R[j+1]&&j<m) j++;
if(temp>R[j]) break;
R[s]=R[j];
s=j;
j=j*2;
}
R[s]=temp;
}
3)函数调用关系图
main()
void Heap_Sort(int n)
void BuildHeap(int n)
void Heapify(int s,int m)
for(i=n;i>1;i--)
{ //对当前无序区R[1……n]进行堆排序,共做n-1趟
R[0]=R[1];//将堆顶和堆中最后一个元素交换
R[1]=R[i];//将R[1……n]重新调整为堆,仅有R[1]可能会违反堆性质
R[i]=R[0];
Heapify(1,ioid BuildHeap(int n)
for(i=1;i<=n;i++)
printf("%3d",R[i]);
printf("\n");
}
(2)void Heap_Sort(int n)堆排序函数模块
void Heap_Sort(int n)
{//对R[1……n]进行堆排序,用R[0]做暂存单元
int i;
BuildHeap(n);//将R[1-n]简称初堆
if(temp>R[j]) break;
R[s]=R[j];
s=j;
j=j*2;
}
R[s]=temp;
}
void BuildHeap(int n)
{//由一个无序的序列简称一个堆
int i;
for(i=n/2;i>0;i--)
Heapify(i,n);
}
void Heap_Sort(int n)
{//对R[1……n]进行堆排序,用R[0]做暂存单元
运行界面
先输入数组A元素的个数后,回车:
再输入数组A的元素值:后回车:
输出排好序后的A中的元素:
八、实验小结:
排序算法有很多,堆排序是其中之一,比如有冒泡排序,快速排序,插入排序等,每个算法都自己的优缺点,学习完堆排序和编写完堆排序的程序后,对堆排序有了更深层次的理解,此次编程还是遇到了些许问题,但是通过查阅图书馆相关的参考书目,能够顺利的完成本次作业。
Heapify(1,i-1);
}
}
void main()
{
int i,n;
printf("请输入数组A元素的个数:");
scanf("%d",&n);
if(n<=0||n>MAX)
{
printf("请重新输入n");
}
printf("请输入数组A的元素值\n");
for(i=1;i<=n;i++)
scanf("%d",&R[i]);
2、输出的形式:输出排好序后的数组A中的元素值。
3、程序所能达到的功能:程序能将一个数据类型为整型的一维数组A,且数组A中的元素呈现无序状态,运行程序后能将A中的数据元素按从小到大的顺序输出。
4、测试数据:输入数组A的元素个数n为6,数组A中的元素分别为8,5 12,9,23,66并用空格将数隔开,回车如:
请输入数组A的元素值: 8 5 12 9 23 66
输出排好序后的A中的元素:5 8 9 12 23 66
2、测试结果:
例如:输入:
8 5 12 9 23 66
输出:5 8 9 12 23 66
3、调试中的错误及解决办法。
调试过程中,遇到了许多的问题,在建堆,堆调整和堆排序的过程中遇到了一些问题,通过查阅与数据结构相关联的的一些参考书目,能够将问题解决,比如堆排序有建大堆和小堆之分,然后排序结果有降序和升序的方法,开始是是按降序输出的结果,将R[j],R[j+1]关系做了调整后,得到升序的结果
{//由一个无序的序列简称一个堆
int i;
for(i=n/2;i>0;i--)
Heapify(i,n);
}
堆调整函数模块
void Heapify(int s,int m)
{//对R[1……n]进行堆调整,用temp做暂存单元
int j,temp;
temp=R[s];
j=2*s;
while(j<=m)
int i;
BuildHeap(n);//将R[1-n]简称初堆
for(i=n;i>1;i--)
{ //对当前无序区R[1……n]进行堆排序,共做n-1趟
R[0]=R[1];//将堆顶和堆中最后一个元素交换
R[1]=R[i];//将R[1……n]重新调整为堆,仅有R[1]可能会违反堆性质
R[i]=R[0];
3、完整的程序:
#include"stdio.h"
#define MAX 255
int R[MAX];
void Heapify(int s,int m)
{//对R[1……n]进行堆调整,用temp做暂存单元
int j,temp;
temp=R[s];
j=2*s;
while(j<=m)
{
if(R[j]<R[j+1]&&j<m) j++;
8 5 12 9 23 66
5 8 9 12 23 66
输出排序好后的数组A为:5 8 9 12 23 66.
五、概要设计
为了实现上述操作,应以数组为存储结构。
1、基本操作:
(1)void Heapify(int s,int m)
(2)void BuildHeap(int n)
(3)void Heap_Sort(int n)
2、软件环境:Microsoft Windows XP Professional Service Pack 3,Microsoft Visual C++ 6.0
四、需求分析
1、输入的形式和输入值的范围:根据题目要求与提示先输入一维数组A的个数n,然后输入数组A中的元素,且数与数之间用空格隔开,回车。
一、实验目的
(1)了解堆排序方法概念;
(2)理解堆排序方法的求解过程;
(3)掌握堆排序方法运算
二、实验内容
(1)建立包含10个数据序列的堆(数据元素的值由自己设定);
(2)完成堆排序运算的程序;
(3)给出程序和堆排序前后的结果。
三、实验环境
1、硬件配置:Pentium(R)Dual-Core9 CUP E6500 @2.93GHz,1.96的内存
2、本程序包含二个模块:
(1)主程序模块;
(2)堆排序模块,建堆模块,堆调整模块
(3)模块调用图:
主程序模块
堆排序模块
建堆模块
堆调整模块
3、流程图
流程图见最后一页
六、详细设计
1、存储类型,
int R[MAX];
元素类型为整形。
2、每个模块的分析:
(1)主程序模块:
void main()
{
int i,n;
签名:
日期:
实验成绩:
批阅日期:
相关文档
最新文档