排序方法比较程序的设计与实现程序设计报告

沈阳航空航天大学
课程设计报告
课程设计名称：C语言课程设计
课程设计题目：排序方法比较程序的设计与实现
院（系）：计算机学院
专业：计算机科学与技术
班级：1434010105
学号：143401010518
姓名：韩冰
指导教师：夏秀峰
完成日期：2015年6月23日
沈阳航空航天大学课程设计报告
目录
第1章概要设计 (1)
1.1题目的内容与要求 (1)
1.2总体结构 (1)
第2章详细设计 (2)
2.1主模块 (2)
2.2显示模块 (2)
2.3分词模块 (4)
2.4替换模块............................................................................... 错误！未定义书签。

第3章调试分析 . (5)
第4章使用说明与执行结果 (6)
参考文献 (11)
附录（程序清单） (12)
签。

第1章概要设计
第1章概要设计
1.1题目的内容与要求
课程设计的内容是设计一个比较不同排序方法数据交换次数与数据比较次数的程序
要求：
（1）输入要生成的数据个数，并生成相应数量的随机数
（2）使用不同的排序法对随机数组进行排序。

并且比较排序期间数据的交换次数与比较次数
（3）比较结束后输出结果。

结果中包括使用该排序法的交换次数、比较次数及使用时间
（4）采用VC环境进行调试运行。

1.2总体结构
本程序主要分为二个模块（模块图见图1.1）：显示模块，排序模块，显示模块：输入要生成的随机数个数。

然后显示选项供用户进行选择。

排序模块：根据用户选择的排序算法。

对随机数进行排序。

图1.1 功能模块图
第2章详细设计
2.1主模块
控制整个程序的运行，控制菜单操作，通过主函数模块分别调用各个模块，实现各项功能，流程如图2.1所示。

图2.1 主模块流程图
注释：
1、输入生成随机数是胡良
2.、无限循环进行，打印主菜单，输入choose值，判断，进行各项操作。

2.2显示模块
输入生成随机数数量后显示相应功能界面如图2.2所示。

图2.2 显示模块流程图注释：
1.定义变量random_number
2.输入随机数数量后输出功能菜单
2.3排序模块
图2.3 排序模块流程图注释：
1、进入功能菜单后输入相应数字
2、根据数字选择排序法进行排序并记录比较与交换次数
第3章调试分析
第3章调试分析
问题1：
重新生成随机数时生成的随机数与上一次生成的随机数相同
解决方法：
经过分析这是因为随机数种子默认均为0导致的问题。

利用time.h头文件中的srand函数对随机数种子进行变更达到重复生成不同随机数
问题2：少量数据计时为0ms
解决方法：经过分析这是因为进行少量数据排序时交换次数与比较次数过少导致运算速度过快。

时间不足1ms导致。

最后利用windows.h中的CPU时钟频率相关函数实现以微秒及以上为单位的高精度计时
问题3：在同一次运行程序使用两种不同的排序法比较第二种排序法不存在交换次数
解决方法：经过检查这是因为经过排序后的数组并没有重置为原来未排序状态，导致第二个排序法运行时无需排序就得到了正确的顺序，最后决定为四种排序法建立四个存放数据的数组。

防止因为使用不同排序法排序相同数组而引发的各种bug
问题4：使用快速排序法时，时间经常十分短暂。

并且固定。

解决方法：因为函数内涉及到递归，导致频繁的重置time值。

最后决定将快速排序法变为无返回值类型。

并且在主函数调用之前和调用之后进行计时。

第4章使用说明与执行结果
此时输入随机数的数量，若输入了范围之外的数据会显示数据错误并要求重新输入
为了体现不同排序法的复杂度差距我们输入30000 让程序随机生成30000组数据
输入了正确范围的数据，显示功能菜单。

通过选择不同的序号实现不同排序法的交换次数与比较次数转换
我们首先选择5 输出随机数
每排6个数字。

进行右对齐规范化输出输出后sleep4000ms后继续输出功能菜单
依次输入1、2、3、4得到四种排序法的排序结果
每一次输出完数据后都会暂停4s后输出主菜单
然后输入序号7 进行比较（序号选择顺序随意。

进行比较前可以不先运行1.2.3.4 因为各功能独立）
程序会规范化输出四种排序法的比较次数交换次数与使用时间（ms）。

输出结果后会要求重新数据数量，进行随机数的重新生成
输入0。

直接退出程序。

以下是以49999为随机数据数量与以400为随机数据数量直接进行的四种排序法的比较结果
参考文献
[1]Brian W.Kernighan/Dennis M.Ritchie C程序设计经典[M] 机械工业出版社 2014
[2]杨丽郭锐陈雪峰 C语言程序开发范例经典[M] 人民邮电出版社 2013
[3]Ivor Horton C语言入门经典第五版[M] 清华大学出版社
[4]戴艳零基础学算法机械工业出版社[M] 2014
[5]Mdash 数据结构与算法分析C语言描述[M] 机械工业出版社 2014
[6]Windows 各种计时函数总结 MoreWindowsS
/morewindows/article/details/6854764
附录（程序清单）
#include<stdio.h>
#include<stdlib.h>
#include<time.h>//生成随机数时所用随机数种子函数以及时间函数
#include<windows.h>//高精度计时调用winAPI
#define random(x) (rand()%x)
LARGE_INTEGER nFreq;
LARGE_INTEGER nBeginTime;
LARGE_INTEGER nEndTime;
int main()
{
/*函数声明部分*/
void random_number(int a[],int len); //随机数生成函数
void print();
void print2();//功能选择界面
void print_answer(int a, int b, double time);
double select_sort(int a[], int count[], int len);
double bubble_sort(int a[], int count[], int n);
void quick_sort(int a[], int count[], int left, int right);
double insert_sort(int a[], int count[], int len); //四种排序法函数声明
/*变量声明部分*/
int length,choose;
int
basic_number[50000],select_number[50000],bubble_number[50000],quick_number[50000],insert_ number[50000];
int select_count[2] = {0}, bubble_count[2] = { 0 }, quick_count[2] = { 0 }, insert_count[2] = { 0 };
double select_time, bubble_time, quick_time, insert_time;
print();
leap:
while (1)
{
printf("请输入数据生成数量(1<number<50000):");
scanf("%d", &length);
if (length >= 50000 || length <= 1)
{
printf("数据生成范围错误！请重新输入\n");
}
else
{
break;
}
}
random_number(basic_number, length);
memcpy(select_number, basic_number, sizeof(basic_number));
memcpy(bubble_number, basic_number, sizeof(basic_number));
memcpy(quick_number, basic_number, sizeof(basic_number));
memcpy(insert_number, basic_number, sizeof(basic_number)); //拷贝随机数到四种排序法所对应的数组中
while (1)
{
print2();
printf("请输入序号:");
scanf("%d",&choose);
if (choose == 1||choose==7)
{
select_time=select_sort(select_number, select_count, length);
if (choose != 7)
{
print_answer(select_count[0], select_count[1], select_time);
memcpy(select_number, basic_number, sizeof(int)*length);//重置数组为未排序状态
memset(select_count, 0, sizeof(select_count));
select_time = 0;//重置变量
Sleep(4000);
}
}
if (choose == 2||choose==7)
{
bubble_time = bubble_sort(bubble_number, bubble_count, length);
if (choose != 7)
{
print_answer(bubble_count[0], bubble_count[1], bubble_time);
memcpy(bubble_number, basic_number, sizeof(int)*length);//重置数组为未排序状态
memset(bubble_count, 0, sizeof(bubble_count));
bubble_time = 0;//重置变量
Sleep(4000);
}
}
if (choose == 3||choose==7)
{
QueryPerformanceFrequency(&nFreq);
QueryPerformanceCounter(&nBeginTime);
quick_sort(quick_number, quick_count, 1, length - 1);
QueryPerformanceCounter(&nEndTime);
quick_time = (double)(nEndTime.QuadPart - nBeginTime.QuadPart) * 1000 / (double)nFreq.QuadPart;
if (choose != 7)
{
print_answer(quick_count[0], quick_count[1], quick_time);
memcpy(quick_number, basic_number, sizeof(int)*length);//重置数组为未排序状态
memset(quick_count, 0, sizeof(quick_count));
quick_time = 0;//重置变量
Sleep(4000);
}
}
if (choose == 4||choose==7)
{
insert_time = insert_sort(insert_number, insert_count, length);
if (choose != 7)
{
print_answer(insert_count[0], insert_count[1], insert_time);
memcpy(insert_number, basic_number, sizeof(int)*length);//重置数组为未排序状态
memset(insert_count, 0, sizeof(insert_count));
insert_time = 0;//重置变量
Sleep(4000);
}
}
if (choose == 5)
{
int temp = 0;
for (int i = 0;i < length;i++)
{
printf("%7d",basic_number[i]);
temp++;
if (temp % 6 == 0)
{
printf("\n");
}
}
Sleep(4000);
}
if (choose == 6)
{
goto leap;
}
if (choose == 7)
{
printf(" 选择排序法冒泡排序法快速排序法插入排序法\n");
printf("比较次数 %-14d%-14d%-14d%-14d\n",select_count[0],
bubble_count[0],quick_count[0],insert_count[0]);
printf("交换次数 %-14d%-14d%-14d%-14d\n",select_count[1],
bubble_count[1], quick_count[1], insert_count[1]);
printf("使用时间
(ms) %-14.4lf%-14.4lf%-14.4lf%-14.4lf\n",select_time,bubble_time,quick_time,insert_time) ;
Sleep(5000);
goto leap;
}
if (choose == 0)
{
printf("谢谢使用\n");
return;
}
if(choose<0||choose>7)
{
printf("序号输入错误，请重新输入\n");
continue;
}
}
}
void print()
{
printf("\n 排序方法比较程序的设计与实现\n");
printf(" ----143401010518 韩冰\n\n\n\n");
}
void print2()
{
printf("\n 请选择您要使用的排序方法\n");
printf(" 1->选择排序法\n");
printf(" 2->冒泡排序法\n");
printf(" 3->快速排序法\n");
printf(" 4->插入排序法\n");
printf(" 5->输出随机数\n");
printf(" 6->重新生成随机数\n");
printf(" 7->四种排序法比较\n");
printf(" 0->退出\n\n\n");
}
void print_answer(int a,int b,double time)
{
printf("比较次数:%d 交换次数:%d\n",a,b);
printf("用时%lf ms\n",time);
}
void random_number(int a[],int len)
{
srand((unsigned int)time(NULL));
for (int i = 0;i < len;i++)
{
a[i] = random(100000); //随机生成0-99999的数
}
}
double select_sort(int a[],int count[], int len) //选择排序法
{
int i, j, k, t;
int compare=0; //比较次数统计
int change=0; //交换次数统计
double time;
QueryPerformanceFrequency(&nFreq);
QueryPerformanceCounter(&nBeginTime);
for (i = 0;i<len;i++)
{
k = a[i];
t = i;
for (j = i;j<len;j++)
{
compare++; //此处进行了比较
if (a[j]<k)
{
k = a[j];
t = j;
}
}
a[t] = a[i];//此处进行了交换
a[i] = k;
change++;
}
QueryPerformanceCounter(&nEndTime);
count[0] = compare;
count[1] = change;
return time = (double)(nEndTime.QuadPart - nBeginTime.QuadPart)*1000 / (double)nFreq.QuadPart;
}
double bubble_sort(int a[],int count[], int n) //冒泡排序法
{
int i, j, temp;
int compare=0; //比较次数统计
int change=0; //数据交换次数统计
double time;
QueryPerformanceFrequency(&nFreq);
QueryPerformanceCounter(&nBeginTime);
for (j = 0; j < n - 1 ; j++)
{
for (i = 0; i < n - j - 1 ; i++)
{
compare++; //进行了比较
if (a[i] > a[i + 1])
{
temp = a[i];
a[i] = a[i + 1];
a[i + 1] = temp;
change++; //若条件成立进行交换;
}
}
}
QueryPerformanceCounter(&nEndTime);
count[0] = compare;
count[1] = change;
return time = (double)(nEndTime.QuadPart - nBeginTime.QuadPart)*1000 / (double)nFreq.QuadPart;
}
void quick_sort(int a[], int count[], int left, int right) //快速排序法
{
int i, j, t, temp;
if (left > right)
{
return; //不能省略否则无法停止。

导致出现堆栈溢出情况}
i = left;
j = right;
temp = a[left];
while (i != j)
{
while (a[j] >= temp&&i < j)
{
j--;
count[0]++;//进行一次比较进入循环
}
if (a[j] < temp)
{
count[0]++; //因为a[j]>=t比较条件未满足跳出循环，}
while (a[i] <= temp&&i < j)
{
i++;
count[0]++;
}
if (a[i] > temp)
{
count[0]++;
}
if (i < j)
{
t = a[i];
a[i] = a[j];
a[j] = t;
count[1]++;//满足条件进行一次交换
}
}
a[left] = a[i];
a[i] = temp; //基准点交换
quick_sort(a, count, left, i - 1);
quick_sort(a, count, i + 1, right);
}
double insert_sort(int a[], int count[], int len) //直接插入排序法{
int compare = 0;
int change = 0;
double time;
QueryPerformanceFrequency(&nFreq);
QueryPerformanceCounter(&nBeginTime);
for (int i = 1; i < len; i++)
{
int k;
int t = a[i];
for (k = i - 1; k >= 0 && a[k] >= t; k--)
{
a[k + 1] = a[k];
compare++;
change++;
}
a[k + 1] = t;
compare++;
}
QueryPerformanceCounter(&nEndTime);
count[0] = compare;
count[1] = change;
return time = (double)(nEndTime.QuadPart - nBeginTime.QuadPart)*1000 / (double)nFreq.QuadPart;
}
/**************************以下为标准排版的源代码*******************************/
沈阳航空航天大学课程设计报告。