根据在排序过程中记录所占用的存储设备,将排序分为:
1.内部排序 待排序记录存放在计算机内存中。
2.外部排序 待排序记录数量大,内存一次不能容纳全部记录,需要对外存进行访问。
内部排序分类:
1.插入类
2.交换类
3.选择类
4.归并类
5.分配类
一、插入排序
按关键字的大小插入到已经排好序的一组记录中的适当位置,直到所有记录全部插入位置。按照查找插入位置的方法不同,分为直接插入排序、折半插入排序和希尔排序。
//待排序数据类型
#define MAXSIZE 20
typedef int KeyType;
typedef struct{
KeyType key;
InfoType otherinfo;
}RedType;
typedef struct{
RedType r[MAXSIZE+1]; //r[0]闲置或用作哨兵
int length;
}SqList;
1.1直接插入排序
算法描述
void InsertSort(SqList &L)
{
for(i=2;i<=L.length;++i) //大循环,从第二个值开始排序
{
if(L.r[i].key<L.r[i-1].key) //与i之前的已经排序好的值进行一一比较,逐个挪动
{
L.r[0]=L.r[i];
L.r[i]=L.r[i-1];
for(j=i-2;L.r[0]<L.r[j];--j)
L.r[j+1]=L.r[j];
L.r[j+1]=L.r[0];
}
}
}
1.2折半插入排序
在查找插入位置的时候用的是查找方式是“折半查找”。
算法描述
void BInsertSort(SqList &L)
{
for(i=2;i<=L.length;i++)
{
L.r[0]=L.r[i];
low=1;high=i-1;
while(low<high) //首先运用折半查找找到插入位置,最后结果总是low>high
{
m=(low+high)/2;
if(L.r[0]<L.r[m]) high=m-1;
low=m+1;
}
for(j=i-1;j>high;--j) //将i的值挪动到i+1上,最后将high+1的值挪动到high+2上,high+1的值为L.r[0]
{
L.r[j+1]=L.r[j];
}
L.r[high+1]=L.r[0];
}
}
1.3希尔排序
实质上是采用分组插入的方法。将记录分成几组,从而减少了参与直接排序的数据量,对每组进行直接插入排序,然后增加每组的数据量,重新分组,经过几次排序之后,整个序列中的记录“基本有序”,再对全体记录进行一次直接插入排序。
void ShellInsert(SqList& L,int dk)
{
for(i=dk+1;i<=L.length;++i)
if(L.r[i].key<L.r[i-dk].key)
{
L.r[0]=L.r[i];
for(j=i-dk;j>0&&L.r[0].key<L.r[j].key;j-=dk)
L.r[j+dk]=L.r[j];
L.r[j+dk]=L.r[0];
}
}
void ShellSort(SqList& L,int dt[],int t)
{
for(k=0;k<t;++k)
ShellInsert(L,dt[k]);
}
二、交换排序
基本思想:两两比较待交换记录的关键字,若两个记录不符合次序要求,则进行交换。
2.1冒泡排序
从1—n两两比较关键字,不符合次序要求则交换,第一趟结束将关键字最大的记录交换到数组最右边,第二次同理从1—(n-1)执行交换……
算法描述
void BubbleSort(SqList &L)
{
m=L.length-1;flag=1;
while((m>0)&&flag==0)
{
flag=0;
for(j=1;j<=m;++j)
{
if(L.r[j].key>L.r[j+1].key)
{
flag=1;
t=L.r[j];L.r[j]=L.r[j+1];L.r[j]=t;
}
}
--m;
}
}
2.2 快速排序
在冒泡排序中每次交换两个相邻记录只能消除一个逆序,如果能通过一次交换消除多个逆序,则会大大加快排序的速度,快速排序方法中的一次交换可消除多个逆序。
算法描述
//快速排序
int Partition(SqList& L,int low,int high)
{
L.r[0]=L.r[low];
pivotkey=L.r[low].key;
while(low<high)
{
while(L.r[high].key>pivotkey&&low<high) --high;
L.r[low]=L.r[high];
while(L.r[low].key<pivotkey&&low<high) ++low;
L.r[high]=L.r[low];
}
L.r[low]=L.r[0];
return low;
}
void QSort(SqList &L,int low,int high)
{
if(low<high)
{
pivoloc=Partition(L,low,high);
QSort(L,low,pivoloc-1);
QSort(L,pivoloc+1,high);
}
}
void QuickSort(SqList &L)
{
QSort(L,1,L.length);
}
三 选择排序
基本思想:每一趟从带排序的记录中选出关键字最小的记录,按顺序放在已排好序的序列的最后。
3.1 简单选择排序
将数组总r[1]与人r[2]-r[n]比较,找到关键字最小的记录,与r[1]交换,再从r[2]开始,与r[3]-r[n]比较,找到关键字最小的记录,与r[2]交换,……(移动次数较少,只需要一个辅助空间)
算法描述
void SelectSort(Sqlist &L)
{
for(i=1;i<L.length;++i)
{
k=i;
for(j=i+1;j<L.length;++i)
{
if(L.r[j].key<L.r[k].key) k=j;
}
if(k!=i)
{
t=L.r[k];L.r[k]=L.r[i];L.r[i]=t;
}
}
}
选择排序的主要操作是进行关键字的比较,因此改进简单选择排序应从如何减少比较次数出发。
3.2 堆排序
将排序记录r[1……n]看成是一颗完全二叉树的顺序存储结构。
节点大于左子树和右子树,称为大根堆,节点小于左子树和右子树,称为小根堆。
算法思路:1 初建堆 2 交换r[1]与r[n],调整堆,交换r[1]与r[n-1]调整堆……
算法描述:
//调整堆
void HeapAdjust(Sqlist &L,int s,int m)
{
rc=L.r[s]; //将r[s]值储存起来,在调整过程中不插入
for(j=2*s;j<=m;j*=2)
{
if(j<m&&L.r[j].key<L.r[j+1].key) ++j;
if(rc.key>=L.r[j]) break;
L.r[s]=L.r[j];s=j; //这里先不插入,最后插入
}
L.r[s]=rc.key; //循环结束再将r[s]值插入
}
//初建堆
void CreatHeap(Sqlist &L)
{
n=L.length;
for(i=n/2;i>=1;--i)
{
HeapAdjust(L,i,n);
}
}
//堆排序算法
void HeapSort(Sqlist &L)
{
CreatHeap(L); //初建堆
for(i=L.length;i>=1;i--)
{ //不断交换并调整堆
t=L.r[1];
L.r[1]=L.r[i];
L.r[i=t;
HeapAdjust(L,1,i-1);
}
}
四 归并排序
基本思路是将两个或两个以上的有序表合并成一个有序表的过程。
算法描述:
void Merge(RedType R[],RedType &T[],int low,int mid,int high)
{
i=low,j=mid+1,k=low;
while(i<=mid&&j<=high)
{
if(R[i].key>=R[j].key) T[k++]=R[j++];
else T[k++]=R[i++];
}
while(i<=mid) T[k++]=R[i++]; //将剩余的直接复制到T[k]中去
while(j<=high) T[k++]=R[j++];
}
void Msort(RedType R[],RedType &T[],int low,int high)
{
if(low==high) T[low]=R[low]; //分割到一组就一个元素后存入T中
else //接下来两两归并排序
{
mid=(low+high)/2;
Msort(R,S,low,mid);
Msort(R,S,mid+1,high);
Merge(S,T,low,mid,high);
}
}
void MergeSort(Sqlist &L)
{
Msort(L.r,L.r,1,L.length)
}