Sort Algo

/*
* Auth:kaixiaozhang
* data:2014-03-28
* addr:BeiJing
* call:kaixiaozhang@sina.com
* cont:sort algo(bubble/select/insert/shell/heap/merge/quick/)
*/

//sort begin
#define MAXSIZE 10

typedef struct        
{
int r[MAXSIZE+1];//存储排序数组，r[0]用作哨兵
int length;     //记录表长
}SqList;

//交换函数，频繁用到
void swap(SqList*L,int i,int j)
{
int temp=L->r[i];
L->r[i]=L->r[j];
L->r[j]=temp;
}

//简单的冒泡排序，简单的交换排序
void BubbleSort0(SqList*L)
{
int i,j;
for (i=1;i<L->length;i++)
{
for (j=i+1;j<=L->length;j++)
{
if (L->r[i]>L->r[j])
{
swap(L,i,j);
}
}
}
}
//冒泡法，反序交换
void BubbleSort(SqList*L)
{
int i,j;
for (i=1;i<L->length;i++)
{
for (j=L->length-1;j>=i;j--)//从后面开始
{
if (L->r[j]>L->r[j+1])
{
swap(L,j,j+1);
}
}
}
}
//优化后的冒泡算法
void BubbleSort2(SqList*L)
{
int i,j;
BOOL flag=TRUE;//标记
for (i=1;i<L->length&&flag;i++) //如果flag为true，说明有数据交换，为false说明无数据交换，可停止循环了
{
flag=FALSE;
for (j=L->length-1;j>=i;j--)
{
if (L->r[j]>L->r[j+1])
{
swap(L,j,j+1);
flag=TRUE;//有数据交换，则值为真。
}
}
if (!flag)
{
return;
}
}
}

//选择排序
void SelectSort(SqList*L)
{
int i,j,min;
for (i=1;i<L->length;i++)
{
min=i;
for (j=i+1;j<=L->length;j++)
{
if (L->r[min]>L->r[j])
{
min=j;
}
}
if (i!=min)
{
swap(L,i,min);
}
}
}

//直接插入排序
void InsertSort(SqList*L)
{
int i,j;
for (i=2;i<=L->length;i++)//i从2开始就是假设1处为已经排好的值，其他值就是插入到它左侧还是右侧的问题
{
if (L->r[i]<L->r[i-1])//
{
L->r[0]=L->r[i];//设置哨兵
for (j=i-1;L->r[j]>L->r[0] && j >= 0;j--)
{
L->r[j+1]=L->r[j];
}
L->r[j+1]=L->r[0];
}
}
}

//希尔排序
void ShellSort(SqList*L)
{
int i,j;
int increment=L->length;
do
{
increment=increment/3+1; //增量序列，每次距离减小
for (i=increment+1;i<=L->length;i++)
{
if (L->r[i]<L->r[i-increment])
{
L->r[0]=L->r[i];
for (j=i-increment;j>0&&L->r[0]<L->r[j];j-=increment)
{
L->r[j+increment]=L->r[j];//记录后移，查找插入位置
}
L->r[j+increment]=L->r[0];//插入
}
}
} while (increment>1);
}

//堆排序，适用于完全二叉树，元素个数为2的n次方+1
void HeapSort(SqList *L)
{
int i;
for (i=L->length/2;i>0;i--)//将原始序列转为堆序列，为什么是length/2,？因为根据完全二叉树的性质，每个双亲访问其子孩子可完全遍历整棵树
{
HeapAdjust(L,i,L->length);
}

for (i=L->length;i>1;i--)//将堆顶元素与最末元素交换，继续调整序列为堆序列
{
swap(L,1,i);
HeapAdjust(L,1,i-1);
}
}//最终L为有序序列
void HeapAdjust(SqList*L,int s,int m)
{
int temp,j;
temp=L->r[s];
for (j=2*s;j<=m;j*=2)
{
if (j<m&&L->r[j]<L->r[j+1])
{
++j;
}
if (temp>=L->r[j])
{
break;
}
L->r[s]=L->r[j];
s=j;
}
L->r[s]=temp;//插入
}

//归并排序，占用内存较多
void MergeSort(SqList*L)
{
MSort(L->r,L->r,1,L->length);
}
void MSort(int SR[],int TR1[],int s,int t)
{
int m;
int TR2[MAXSIZE+1];
if (s==t)
{
TR1[s]=SR[s];
}
else
{
m=(s+t)/2;//将SR[s……t]平分为SR[s……m]和ST[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 Merge(int SR[],int TR[],int i,int m,int n)//将有序的SR[s……m]和ST[m+1……t]归并为有序的TR[i……n]
{
int j,k,l;
for (j=m+1,k=i;i<=m&&j<=n;k++)//将SR中记录由小到大归并乳TR
{
if (SR[i]<SR[j])
{
TR[k]=SR[i++];
}
else
TR[k]=SR[j++];
}

if(i<=m)//将剩余的SR[i……m]复制到TR
{
for (l=0;l<=m-i;l++)
{
TR[k+l]=SR[i+1];
}

}

if (j<=n)//将剩余的SR[j……n]复制到TR
{
for (l=0;l<=n-j;l++)
{
TR[k+l]=SR[j+1];
}
}
}
void MergeSort2(SqList* L)//不用递归的归并排序
{
int* TR=(int*)malloc(L->length*sizeof(int));//申请额外空间
int k=1;
while (k<L->length)
{
MergePass(L->r,TR,k,L->length);
k=2*k;
MergePass(TR,L->r,k,L->length);
k=2*k;
}
}
void MergePass(int SR[],int TR[],int s,int n)//将SR中相邻长度为s的子序列两两归并到TR[]
{
int i=1;
int j;
while (i<=n-2*s+1)
{
Merge(SR,TR,i,i+s-1,i+2*s-1);
i=i+2*s;
}
if (i<n-s+1)
{
Merge(SR,TR,i,i+s-1,n);

}
else
for (j=i;j<=n;j++)
{
TR[j]=SR[j];
}
}

//快速排序
void QuickSort(SqList*L)
{
QSort(L,1,L->length);
}
void QSort(SqList*L,int low,int high)//对顺序表L中的子序列L->r[low...high]做快速排序
{
int pivot;
if (low<high)
{
pivot=Partition(L,low,high);//将L->r[low...high]一分为二,算出枢轴值pivot
QSort(L,low,pivot-1);//对低子表递归排序
QSort(L,pivot+1,high);//对高子表递归排序
}
}
//partition作用就是选取序列当中的一个关键字，想尽办法将其放到一个位置，使得它左边的值都比它小，右边都比它大，这样的关键字称为枢轴
int Partition(SqList*L,int low,int high)
{
int pivotKey;
//优化选取枢轴值 三值取中 开始
  int m=low+(high-low)/2;
  if (L->r[low]>L->r[high])
  {
  swap(L,low,high);
  }
  if (L->r[m]>L->r[high])
  {
  swap(L,high,m);
  }
  if (L->r[m]>L->r[low])
  {
  swap(L,m,low);
  }
//此时L->r[low]已经为整个序列左中右三个关键字的中间值
//优化选取枢轴值 三值取中 结束

pivotKey=L->r[low];//用子表的第一个记录做枢轴记录
while (low<high)//从表的两端交替向中间扫描
{
while (low<high&&L->r[high]>=pivotKey)
{
high--;
}
swap(L,low,high);//将比枢轴记录小的记录交换到低端
while (low<high&&L->r[low]<=pivotKey)
{
low++;
}
swap(L,low,high);//将比枢轴记录大的记录交换到高端
}
return low;//返回枢轴所在位置
}
int Partition1(SqList*L,int low,int high)//优化不必要的交换
{
int pivotkey;
pivotkey=L->r[low];
L->r[0]=pivotkey;//将枢轴值备份到L->r[0]
while (low<high)
{
while(low<high&&L->r[high]>=pivotkey)
high--;
L->r[low]=L->r[high];//采用替换而不是交换的方式进行操作
while(low<high&&L->r[low]<=pivotkey)
low++;
L->r[high]=L->r[low];//采用替换而不是交换的方式进行操作
}
L->r[low]=L->r[0];//将枢轴值替换为L->r[low]
return low;
}



//优化小数组时的排序方案，小数组排序直接插入式简单排序中性能最好的
#define MAX_LENGTH_INSERT_SORT 7

void QSort(SqList&L,int low,int high)
{
int pivot;
if ((high-low)>MAX_LENGTH_INSERT_SORT)
{
pivot=Partition(&L,low,high);

QSort(&L,low,pivot-1);
QSort(&L,pivot+1,high);
}
else
InsertSort(&L);
}

//优化递归操作，用到了以上的优化内容，可以说是总的优化
void QSort1(SqList*L,int low,int high)
{
int pivot;
if ((high-low)>MAX_LENGTH_INSERT_SORT)
{
while(low<high)
{
pivot=Partition1(L,low,high);
QSort1(L,low,pivot-1);
low=pivot+1;
}
}
else
InsertSort(L);
}
//sort end