数据结构七个排序课程设计

数据结构

课程设计报告

题目：排序的实现

专业：软件工程

班级：1502

学号：

姓名：

时间：2016-12-26—2017-1-6

一、问题描述

1.题目内容：排序算法实现。

2.基本要求：用C语言或者C++设计一个排序综合系统。

3.测试数据：手写输入数据。

二、需求分析

1.程序所能达到的基本功能。

1)设计一个菜单，格式如下：

1.选择排序

2.插入排序-

3.起泡排序

4.快速排序

5.归并排序

6.堆排序

7.基数排序

8.重新输入数据

9.退出

2)选择不同的菜单但进行相应的排序，并给出排序的关键字序列。求出该排序算

法运行时间，比较各排序间效率。

2.输入的形式和输入值的范围：所有整型的数。

3.输出的形式：从小到大输出排序结果和运行时间。

4.测试数据要求。

输入元素个数为正整数。

输入将要排序的数都为整型。

三、概要设计

1.所需的ADT,它们的作用。

ADT SORT{

数据对象：D=用户输入n数据元素；

基本操作：void ShuRu(SqList &L); ------------------- 用户输入

Void SelectSort(SqList &L)；------------------- 选择排序

void nsertSort(SqList &L); ------------------- 插入排序-

void BBubbleSort(SqList &L); ------------------- 起泡排序

void QuickSort(SqList &L); ------------------- 快速排序

void MergeSort(SqList &L); ------------------- 归并排序

void HeapSort(SqList &L); ------------------- 堆排序

void RadixSort(SqList &L) ------------------- 基数排序}ADT SORT

2.主程序流程及模块调用关系。

3.核心的粗线条伪代码算法。

四、详细设计

1.实现概要设计的数据类型，重点语句加注释。

2.每个操作的伪代码算法，重点语句加注释。

3.主程序和其他模块的伪码算法，重点语句加注释。

4.函数调用关系图。

五、调试分析

1.设计与调用过程中遇到的问题及分析、体会。

由于是输入是手打输入，当数据少时，各排序算法运行时间都接近于0，导致时间显示几乎一样，无法进行比较各排序效率。所以在网上找了更加精细计算函数运行

时间的算法。这让我懂得查找资料和思考会让你的算法更加完善。

六、使用说明

1.简要说明程序运行操作步骤。

a)输入需要排序总数。

b)输入数据。

c)根据菜单选择1~8进行排序，重复进行。

d)输入9确定退出。

七、测试结果

包括输入和输出，输入集应多于需求分析的数据。

八、附录（带注释的源程序）

#include

#include

#include

#include

#include

using namespace std;

const MAXSIZE=10000;

typedef struct{

int r[MAXSIZE+1];//r[0]闲置或者作为判别标志的“哨兵”单元int length;//顺序表的记录空间为r[1…length]

}SqList;//顺序表类型

void ShuRu(SqList &L,int n)//输入函数

{

L.length=n;

for (int i=1;i<=L.length;i++)

{

cout<<"r["<

cin>>L.r[i];

}

cout<

}

void ShuChu(SqList L)//输出函数

{

cout<<"排序的结果为：";

for (int i=1;i<=L.length;i++)

{

cout<<" "<

}

}

void SelectSort(SqList &L)//选择排序{

int W;

int j,k;

for(int i=0;i

{

j=i;

for(k=i+1;k<=L.length;k++)

if(L.r[k]

j=k;

if(i!=j)

{W=L.r[j];L.r[j]=L.r[i];L.r[i]=W;} }

}

void InsertSort(SqList &L)//插入排序{

for(int i=2;i<=L.length;++i)

if(L.r[i]

{

L.r[0]=L.r[i];

for(int j=i-1;L.r[0]

L.r[j+1]=L.r[j];

L.r[j+1]=L.r[0];

}

}

void BBubbleSort(SqList &L)//起泡排序{

int W;

int i=L.length;

int lastExchangeIndex;

while(i>1)

{

lastExchangeIndex=1;

for(int j=1;j

{

if(L.r[j+1]

{

W=L.r[j];L.r[j]=L.r[j+1];L.r[j+1]=W;

lastExchangeIndex=j;

}

}

i=lastExchangeIndex;

}

}

int Partition(int R[],int low,int high)//快速排序

{

int pivotkey;

R[0]=R[low];

pivotkey=R[low];

while(low

{

while(low=pivotkey)

--high;

if(low

R[low++]=R[high];

while(low

++low;

if(low

R[high--]=R[low];

}

R[low]=R[0];

return low;

}

void QSort(int R[],int s,int t)//快速排序

{

int pivotloc;

if(s

{

pivotloc=Partition(R,s,t);

QSort(R,s,pivotloc-1);

QSort(R,pivotloc+1,t);

}

}

void QuickSort(SqList &L)//快速排序

{

QSort(L.r,1,L.length);

}

void Merge(int SR[],int TR[],int i,int m,int n)//归并排序{

for(int j=m+1,k=i;i<=m && j<=n;++k)

{

if(SR[i]<=SR[j])

TR[k]=SR[i++];

else TR[k]=SR[j++];

}

while(i<=m)TR[k++]=SR[i++];

while(j<=n)TR[k++]=SR[j++];

}

void MSort(int SR[],int TR1[],int s,int t)//归并排序{

int *TR2=new int[t-s+1];

int m;

if(s==t)TR1[s]=SR[s];

else{

m=(s+t)/2;

MSort(SR,TR2,s,m);

MSort(SR,TR2,m+1,t);

Merge(TR2,TR1,s,m,t);

}

}

void MergeSort(SqList &L)//归并排序

{

MSort(L.r,L.r,1,L.length);

}

void HeapAjust(int *a, int i, int size) //堆排序

{

int lchild = 2*i;

int rchild = 2*i +1;

int max = i;

int temp;

if(i <=size/2)

{

if(lchild<=size && a[lchild]>a[max])

max = lchild;

if(rchild<=size && a[rchild]>a[max])

max = rchild;

if(max != i)

{

temp = a[i];

a[i] = a[max];

a[max] = temp;

HeapAjust(a, max, size);

}

}

}

void BuildHeap(SqList &L) //堆排序

{

int i;

for(i=L.length/2; i>=1;i--)

HeapAjust(L.r, i,L.length);

}

void HeapSort(SqList &L) //堆排序

{

int i;

int temp;

BuildHeap(L);

for(i=L.length; i>=1; i--)

{

temp=L.r[1];

L.r[1]=L.r[i];

L.r[i]=temp;

HeapAjust(L.r, 1, i-1);

}

}

typedef struct node{

int key;

node *next;

}RecType;

void RadixSort(SqList &L)//基数排序

{

int t,i,j,k,d,n=1,m;

RecType *p,*s,*q,*head[10],*tail[10];

for(i=1;i<=L.length;i++)

{

s=(RecType*)malloc(sizeof(RecType));

s->key=L.r[i];

if(i==1)

{

q=s;

p=s;

t++;

}

else

{

q->next=s;

q=s;

t++;

}

q->next=NULL;

}

d=1;

while(n>0)

{

for(j=0;j<10;j++)

{

head[j] = NULL;

tail[j] = NULL;

}

while(p!=NULL)

{

k=p->key/d;

k=k%10;

if(head[k]==NULL)

{

head[k]=p;

tail[k]=p;

}

else

{

tail[k]->next=p;

tail[k]=p;

}

p=p->next;

}

p=NULL;

for(j=0;j<10;j++)

{

if(head[j]!=NULL)

{

if(p==NULL)

{

p=head[j];

q=tail[j];

}

else

{

q->next=head[j];

q=tail[j];

}

}

}

q->next=NULL;

d=d*10;

n=0;

m=1;

while(m<=L.length)

{

if((L.r[m]/d)!=0)

{

n++;

m++;

}

else

m++;

}

}

i=1;

while(p!=NULL)

{

L.r[i]=p->key;

i++;

p=p->next;

}

}

void runtime(void Sort(SqList &L),SqList &L)//计算函数运行时间

{

LARGE_INTEGER litmp;

LONGLONG start, end;

double dft, dff, dfm;

QueryPerformanceFrequency(&litmp);//获得时钟频率dff = (double) litmp.QuadPart;

QueryPerformanceCounter(&litmp);//获得初始值

start = litmp.QuadPart;

Sort(L);

QueryPerformanceCounter(&litmp);//获得终止值

end = litmp.QuadPart;

dfm = (double) (end - start);

dft = dfm / dff;//获得对应的时间值,单位秒

printf("%lf毫秒\n",dfm/dff*1000);

}

int main()

{

SqList L;

SqList L1;

int n,a;

bool j;

while (1)

{

cout<<"输入需要排序总数：";

cin>>n;

while(n<0 || n>MAXSIZE)

{

cout<<"输入错误，请重新输入：";

cin>>n;

}

ShuRu(L1,n);

j=true;

cout<<"下面是排序对应的序号："<

cout<<"1.选择排序"<

cout<<"2.插入排序"<

cout<<"3.起泡排序"<

cout<<"4.快速排序"<

cout<<"5.归并排序"<

cout<<"6.堆排序"<

cout<<"7.基数排序"<

cout<<"8.重新输入数据"<

cout<<"9.退出"<

while(j)

{

cout<<"输入选择进行排序的序号："<

cin>>a;

L=L1;

switch (a)

{

case 1:cout<<"选择排序的运算所用的时间是：";runtime(SelectSort,L);break;

case 2:cout<<"插入排序的运算所用的时间是：";runtime(InsertSort,L);break;

case 3:cout<<"起泡排序的运算所用的时间是：";runtime(BBubbleSort,L);break;

case 4:cout<<"快速排序的运算所用的时间是：";runtime(QuickSort,L);break;

case 5:cout<<"归并排序的运算所用的时间是：";runtime(MergeSort,L);break;

case 6:cout<<"堆排序的运算所用的时间是：";runtime(HeapSort,L);break;

case 7:cout<<"基数排序的运算所用的时间是：";runtime(RadixSort,L);break;

case 8:j=false;break;

default:return 0;

}

if(a<8)ShuChu(L);

cout<

}

}

return 0;

}