几种排序方法

几种排序方法
一、实验目的

1.了解内部排序的定义和基本方法

2.理解排序的基本思想和基本概念

3.掌握插入排序、冒泡排序、快速排序、直接选择排序、堆排序的基本思想、步骤、算法及时空效率分析

二、实验实验环境

    Windows下,编译器为Code::Blocks

三、实验内容

分别对每一个排序表多次运行插入排序、冒泡排序、快速排序、直接选择排序、堆排序，计算其平均运行时间。

四、实验步骤

分别对每一个排序表多次运行插入排序、冒泡排序、快速排序、直接选择排序、堆排序，计算其平均运行时间

  1-创建顺序表        2-进行插入排序         3-进行冒泡排序

  4-进行快速排序      5-进行直接选择排序      6-进行堆排序

7-输出排序后的数据

void CreateSqList(SqList<type> &sl)//创建顺序表

void BInsertSort(SqList<type> &L)//对顺序表L作折半插入排序

void BubbleSort(SqList<type> & L)//冒泡排序

int Partition(SqList<type>& L,int low,inthigh)//快速排序

int SelectMinKey(SqList<type>& L,int n)//简单选择排序的功能模块

 void SelectSort(SqList<type>& L)//对顺序表L作简单选择排序

void HeapAdjust(SqList<type>& L,int s,int m)//堆排序的子功能模块

void HeapSort(SqList<type>& L) //对顺序表L进行堆排序

五、实验小结及问题分析

1.插入排序的基本思想：在一个已排好序的记录子集的基础上，每一步将下 一个待排序的记录有序地插入到已排好序的记录子集中，直到将所有待排记录全部插入为止。

    折半插入排序比直接插入排序明显地减少了关键字间的“比较”次数，但记录“移动”的次数不变。因此，折半插入排序的事件复杂度仍为O(n2)

2.起泡排序：将第一个记录的关键字与第二个记录的关键字进行比较，若为 逆序R[1]>R[2]，则交换；然后比较第二个记录与第三个记录；依次类推

    冒泡排序时间复杂度,最好情况（正序）,比较次数：n-1移动次数：0,最坏情况（逆序）比较次数: 移动次数：,时间复杂为T(n)=O(n²)

3.快速排序：通过一趟排序，将待排序记录分割成独立的两部分，其中一部 分记录的关键字均比另一部分记录的关键字小，则可分别对这两部分记录进行排序，以达到整个序列有序

    快速排序快速排序主体算法时间运算量约O(log2n), 划分子区函数运算量约O(n), 所以总的时间复杂度为O(nlog2n),它显然优于冒泡排序O(n2)。可是算法的优势并不是绝对的, 试分析, 当原文件关键字有序时,快速排序时间复杂度是O(n2),这种情况下快速排序不快。

4.简单选择排序：基本思想：在待排序的数据中选出最大（小）的元素放在其最终的位置。

    直接选择排序时间复杂度,记录移动次数最好情况：0,最坏情况：3(n-1),比较次数：,时间复杂度为T(n)=O(n²)

5.堆排序：若在输出堆顶的最小值（最大值）后，使得剩余n-1个元素的序列重又建成一个堆，则得到n个元素的次小值（次大值）……如此反复，便能得到一个有序序列，这个过程称之为堆排序。

    堆排序，堆排序的时间主要耗费在建初始堆和调整建新堆时进行的反复“筛选”上。 堆排序在最坏情况下，其时间复杂度也为O(nlog2n)， 这是堆排序的最大优点。

具体实现代码.cpp文件

#include<iostream>
using namespace std;
#include"sort2.h"

int main()
{
SqList<int> sl;
int flag;
cout<<"* 主  菜  单  *"<<endl;
cout<<"  0 退出程序"<<endl;
cout<<"  1.插入排序"<<endl;
cout<<"  2.冒泡排序"<<endl;
cout<<"  3.快速排序"<<endl;
cout<<"  4.直接选择排序"<<endl;
cout<<"  5.堆排序"<<endl;
cout<<"请选择主菜单：";
cin>>flag;
while(flag!=0)
{
switch(flag)
{
case 1:
CreateSqList(sl);
BInsertSort(sl);
cout<<"排序结果如下："<<endl;
OutPut(sl);
delete sl.key;
break;
case 2:
CreateSqList(sl);
BubbleSort(sl);
cout<<"排序结果如下："<<endl;
OutPut(sl);
delete sl.key;
break;
case 3:
CreateSqList(sl);
SelectSort(sl);
cout<<"排序结果如下："<<endl;
OutPut(sl);
delete sl.key;
break;
case 4:
CreateSqList(sl);
SelectSort(sl);
cout<<"排序结果如下："<<endl;
OutPut(sl);
delete sl.key;
break;
case 5:
CreateSqList(sl);
HeapSort(sl);
cout<<"排序结果如下："<<endl;
OutPut(sl);
delete sl.key;
break;
}
cout<<"请选择主菜单：";
cin>>flag;
}
}

具体实现代码.h

#include"assert.h"
template<class type>
struct SqList{
type * key;
int length;
};

template<class type>
void CreateSqList(SqList<type> &sl)//创建顺序表
{
int n;
cout<<"建立顺序表"<<endl<<"请输入顺序表的长度"<<endl;
cin>>n;
sl.length=n;
sl.key=new int[sl.length+1];
assert(sl.key);
cout<<"请输入数据："<<endl;
for(int i=1;i<=sl.length;i++)
{
cin>>sl.key[i];
}
}

template<class type>//输出顺序表内的数据
void OutPut(SqList<type> &L)
{
for(int j=1;j<=L.length;++j)
cout<<L.key[j]<<"\t";
cout<<endl;
}

template<class type>//对顺序表L作折半插入排序
void BInsertSort(SqList<type> &L)
{
int high,low,m;
for(int i=2;i<=L.length;i++)
{
L.key[0]=L.key[i];
low=1;
high=i-1;
while(low<=high)
{
m=(low+high)/2;
if(L.key[0]<=L.key[m])
high=m-1;
else
low=m+1;
}
for(int j=i-1;j>=high+1;--j)
L.key[j+1]=L.key[j];
L.key[high+1]=L.key[0];
}
}

template<class type>//冒泡排序
void BubbleSort(SqList<type> & L)
{
for(int i=1;i<L.length;i++)
{
type t;
for(int j=1;j<=L.length-i;j++)
if(L.key[j]>L.key[j+1])
{
t=L.key[j];
L.key[j]=L.key[j+1];
L.key[j+1]=t;
}
}
}

template<class type>//快速排序
int Partition(SqList<type>& L,int low,int high)
{
type pivotkey;
L.key[0]=L.key[low];
pivotkey=L.key[low];
while(low<high)
{
while(low<high&&L.key[high]>=pivotkey) --high;
L.key[low]=L.key[high];
while(low<high&&L.key[low]<=pivotkey) ++low;
L.key[high]=L.key[low];
}
L.key[low]=L.key[0];
return low;
}

template<class type>//简单选择排序的功能模块
int SelectMinKey(SqList<type>& L,int n)
{
int min=n;
type minkey;
minkey=L.key
;
for(int i=n+1;i<=L.length;i++)
if(L.key[i]<minkey)
{
minkey=L.key[i];
min=i;
}
return min;
}
template<class type>
void SelectSort(SqList<type>& L)//对顺序表L作简单选择排序
{
int j;
type t;
for(int i=1;i<=L.length;i++)
4000
{
j=SelectMinKey(L,i);
if(i!=j)
{
t=L.key[i];
L.key[i]=L.key[j];
L.key[j]=t;
}
}
}

template<class type>//堆排序的子功能模块
void HeapAdjust(SqList<type>& L,int s,int m)
{
type rc=L.key[s];
for(int j=2*s;j<=m;j*=2)
{
if(j<m&&L.key[j]<=L.key[j+1])
j++;
if(rc>L.key[j]) break;
L.key[s]=L.key[j];
s=j;
}
L.key[s]=rc;
}
template<class type>//对顺序表L进行堆排序
void HeapSort(SqList<type>& L)
{
type value;
int j;
for(int i=L.length/2;i>0;i--)
HeapAdjust(L,i,L.length);
for(j=L.length;j>1;--j)
{
value=L.key[1];
L.key[1]=L.key[j];
L.key[j]=value;
HeapAdjust(L,1,j-1);
}

}

运行结果为