堆排序实验报告
堆栈模拟队列实验报告
一、实验目的通过本次实验，加深对堆栈和队列数据结构的理解，掌握堆栈的基本操作，并学会利用堆栈模拟队列的功能。
通过实验，培养学生的编程能力和问题解决能力。
二、实验内容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篇)
第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篇)
第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篇)
第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)。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
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;
签名：
日期：
实验成绩：
批阅日期：