c语言各种排序方法代码
学习了各种排序方法后，为加强记忆，在此重新复习一遍。
1----直接插入排序
直接插入排序为稳定的排序方法，原理是将一个记录插入到已经排序号的有序表中，从而得到一个新的，记录数增1的有序表。
算法：
void InsertSort(SqList& L)
{
for(int i=2;i<=L.length;i++)
{
if(L.r[i].key < L.r[i-1].key)
{
L.r[0]=L.r[i];
L.r[i]=L.r[i-1];
for(int j=i-1;(L.r[0].key < L.r[j].key);j--)
L.r[j]=L.r[j-1];
L.r[j]=L.r[0];
}
}
}
2----折半插入排序
也是一种插入排序，稳定的排序方法，原理是在一个有序表中进行插入和删除，查找的过程可以用折半查找来实现。
void BInsertSort(SqList& L)
{
for(int i=2;i<=L.length;i++)
{
L.r[0]=L.r[i];
int low=1,high=i-1;
while(low <= high)
{
int mid=(low + high)/2;
if(L.r[0].key < L.r[mid].key)
high=mid-1;
else
low=mid+1;
}
for(int j=i-1;j>=high+1;j--)
L.r[j+1]=L.r[j];
L.r[high+1]=L.r[0];
}
}
3----希尔排序
跳跃式的插入排序，不稳定的排序方法。增量序列最后一个值必须为1
void ShellInsert(Sqlist& L,int dk)
{
for(int i=dk+1;i<=L.length;i++)
{
if(L.r[i].key < L.r[i-dk].key)
{
L.r[0]=L.r[i];
for(int j=i-dk;j>0 && (L.r[0].key < L.r[j].key);j--)
L.r[j+dk]=L.r[j];
L.r[j+dk]=L.r[0];
}
}
}
void ShellSort(Sqlist& L,int dlta[],int t)
{
for(int k=0;k
}
4----冒泡排序
基于交换的排序，是一种稳定的排序方法
void BubbleSort(Sqlist& L)
{
for(int i=1;i<=L.length;i++)
for(int j=1;j
if(L.r[j].key > L.r[j+1].key)
{
//交换记录值
}
}
}
5----快速排序
交换排序，基于枢轴的排序。
//////////////////////////////////////////////////////////////////////////
//交换顺序表L中子表L.r[low..high]的记录，使枢轴记录到位，并返回其所在位置。
//此时，在它之前的记录均不大于它，之后的记录均不小于它。
int Partition(SqList& L,int low,int high)
{
int pivotkey=L.r[low].key;//子表的第一个记录作枢轴
while (low < high)//从表的两端交替向中间扫描
{
while (low
--high;//从后往前扫描，直到找到一个关键字比枢轴关键字小的记录
//此时交换这两个记录
RedType tmp;
tmp=L.r[low];
L.r[low]=L.r[high];
L.r[high]=tmp;
//交换过后，枢轴的值在L.r[high]位置
while(low
//此时交换这两个记录
tmp=L.r[low];
L.r[low]=L.r[high];
L.r[high]=tmp;
//交换过
后，枢轴的值在L.r[low]位置
}
//while循环结束后，low==high，枢轴在low所在的位置。
return low;
}
/////////////////////////////////////////////////////////////////////////
//递归形式的排序,对一个子序列L.r[low...high]排序
void QSort(SqList& L,int low,int high)
{
if(low
int pivotloc=Partition(L,low,high);//将表L.r[low...high]一分为二
QSort(L,low,pivotloc-1);//低子表递归排序，pivotloc是枢轴位置
QSort(L,pivotloc+1,high);//高子表递归排序
}
}
//最终的排序函数
void QuickSort(SqList& L)
{
QSort(L,1,L.length);
}
6----简单选择排序
//从第i个位置起，到顺序表末尾寻找关键字最小的记录所在的位置，并返回之
int SelectMinKey(SqList& L,int i)
{
int value=MAX_VALUE;
int pos=0;
for (i;i<=L.length;i++)
{
if(L.r[i].key
value=L.r[i].key;
pos=i;
}
}
return pos;
}
//简单选择排序
void SelectSort(SqList& L)
{
for (int i=1;i
int j=SelectMinKey(L,i);//寻找关键字最小的记录
if(i!=j)//与地i个记录交换
{
RedType tmp;
tmp=L.r[i];
L.r[i]=L.r[j];
L.r[j]=tmp;
}
}
}
7----堆排序
//////////////////////////////////////////////////////////////////////////
//筛选算法。
/*
已知H.r[s...m]中记录的关键字除H.r[s].key之外均满足堆的定义，本函数调整
H.r[s]的关键字，使H.r[s...m]成为一个大顶堆（对其中记录的关键字而言）
该函数将把s指向的元素筛选成以s为根节点的子树中关键字最大的记录
m为欲筛选的子树的元素。
*/
void HeapAdjust(HeapType& H,int s,int m)
{
RedType rc=H.r[s];
for (int j=2*s;j<=m;j*=2)//沿key较大的记录的下标筛选
{
if(j
if(!LT(rc.key,H.r[j].key))//若s处的记录大于其孩子中的记录，rc应该插入在位置s上
break;
H.r[s]=H.r[j];
s=j;
}
H.r[s]=rc;//插入
}
//////////////////////////////////////////////////////////////////////////
//堆顺序表H进行堆排序
void HeapSort(HeapType& H)
{
for(int i=H.length/2;i>0;i--)//把H.r[1...H.length]建成大顶堆
HeapAdjust(H,i,H.length);
for (int i=H.length;i>1;i--)
{
RedType tmp;//将堆顶记录和当前未经排序子序列H.r[1...i]中最后一个记录互换
tmp=H.r[1];
H.r[1]=H.r[i];
H.r[i]=tmp;
HeapAdjust(H,1,i-1);//将H.r[1...i-1]重新调整为大顶堆
}
}
8----归并排序
//////////////////////////////////////////////////////////////////////////
//将分段有序的SR[i..m]和SR[m+1..n]归并为有序的TR[i..n]
void Merge(RedType SR[],RedType* TR,int i,int m,int n)
{
int k,j;
//将SR中记录由小到大的并入TR中
for (j=m+1,k=i;i<=m && j<=n;k++)
{
if(LQ(SR[i].key,SR[j].key))
TR[k]=SR[i++];
else
TR[k]=SR[j++];
}
int k1,k2;
//将剩余的序列复制到TR
for (k1=k;i<=m;i++,k1++)
{
TR[k1]=SR[i];
}
for (k2=k;j<=n;j++,k2++)
{
TR[k2]=SR[j];
}
}
//将SR[s..t]归并排序为TR1[s..t]
void MSort(RedType SR[],RedType* TR1,int s,int t)
{
if(s==t)
TR1[s]=SR[s];
else
{
RedType TR2[MAXSIZE];
int m=(s+t)/2;//将SR[s..t]平均的分为SR[s..m]和SR[m+1..t]
MSort(SR,TR2,s,m);//递归的将SR[s..m]归并为有序的TR2[s..m]
MSort(SR,TR2,m+1,t);//递归的将SR[m+1..t]归并为有序的TR2[m+1..t]
Merge(TR2,TR1,s,m,t);//将TR2[s..m]和TR2[m+1..t]归并到TR1[s..t]
}
}
void MergeSort(SqList& L)
{
//对顺序表L作归并排序
MSort(L.r,L.r,1,L.length);
}