几种常见排序算法的实现（冒泡法，选择法，插入法，快速排序、堆排序）

#include "stdafx.h"

//in the i th round ordering, j always points to the max element so far
void bubble_sort(int *a, int len)
{
for(int i=0; i<len-1; i++)
{
for(int j=0; j<len-1-i; j++)
{
if(a[j]>a[j+1])
{
swap<int>(a[j],a[j+1]);
}
}
}
}

void bubble_sort2(int *a, int len)
{
for(int i=0; i<len-1; i++)
{
for(int j=len-1; j>i; j--)
{
if(a[i]>a[j])
{
swap<int>(a[i],a[j]);
}
}
}
}

/*in the i th round ordering, k always points to the min element so far. the additional
variable k gives it a chance to make the swap till a whole round ordering is finished.
so this algorithm should have less sawp operatons than bubble sort.
*/
void select_sort(int *a, int len)
{
int k;
for (int i=0; i<len-1; i++)
{
k=i;
for(int j=len-1; j>i; j--)
{
if(a[k]>a[j]) k = j;
}
if(k!=i)
{
swap<int>(a[k], a[i]);
}
}
}

// every round ordering, we choose the first element as benchmark.
void quick_sort_recursion(int *a, int low, int high)
{
int bench=a[low];
int end=high;
while(low<high)
{
while(low<high && a[high]>=bench) high--;
a[low]=a[high];
while(low<high && a[low]<=bench) low++;
a[high]=a[low];
}
a[low]=bench;//now position low should equal to position high
if(low>1) // there are at least two elements before position low
{
quick_sort_recursion(a, 0, low-1);
}
if(low+1<end) // there are at least two elements after position low
{
quick_sort_recursion(a, low+1, end);
}
}

void quick_sort(int *a, int len)
{
quick_sort_recursion(a, 0, len-1);
}

//every round ordering, we want to insert a[i] to correct postion in an ordered array p[0]-p[i-1]
//we compare a[i] with ordered array p[0]-p[i-1] from back, if a[i] is smaller, than move p[j] to p[j+1]
//else insert a[i] to p[j+1]
void insert_sort(int *a, int len)
{
int *p = new int[len];
int i,j;
for(i=0; i<len; i++)
{
for(j=i-1; j>=0; j--)
{
if(a[i]<p[j])
{
p[j+1] = p[j];
}
else
{
break;
}
}
p[j+1] = a[i];
}
copy(p, p+len, a);
delete [] p;
}

// 堆排序
// 对堆a[m, n]建大顶堆
void heap_adjust(int *a, int m, int n)
{
int rc = a[m];
for(int j=2*m; j<=n; j*=2)
{
if(j+1<=n && a[j+1]>a[j])
{
j++;//如果右节点非空且较大，则取右节点
}
if(rc>=a[j])
{
break;//构建大顶堆完毕
}
else
{
a[m] = a[j];//调整堆
m = j;//记录空位
}
}
a[m] = rc;
}

void heap_sort(int *a, int len)
{
for (int i=(len/2)-1; i>=0; i--)//构建大顶堆
{
heap_adjust(a, i, len-1);
}
for (int i=len-1; i>0; i--)
{
swap<int>(a[0], a[i]);//交换堆顶元素与最后一个元素，得到此轮排序最大值
heap_adjust(a, 0, i-1);//对新的堆a[0, i-1]重新构建大顶堆
}
}