各种排序算法实现

1. 归并排序算法：

非递归实现：

void mergeSort(vector<int> & nums, vector<int> &tmpNums, int left, int right, int end)//right为右边一段数据的开始，同时也可以用来判断左边一段数据的结束，并且左边的数组长度总是大于或等于右边数组长度
{
int idx_left=left;
int idx_right=right;
int idx_total=left;
while(idx_left<right && idx_right<=end)
{
if(nums[idx_left]<=nums[idx_right])
tmpNums[idx_total++]=nums[idx_left++];
else
tmpNums[idx_total++]=nums[idx_right++];
}
while(idx_left<right)
tmpNums[idx_total++]=nums[idx_left++];
while(idx_right<=end)
tmpNums[idx_total++]=nums[idx_right++];

idx_left=left;
while(idx_left<=end)
{
nums[idx_left]=tmpNums[idx_left];
idx_left++;
}
}

void merge(vector<int> & nums, vector<int> & tmpNums)
{
int step=1;
int i;
int n=nums.size();
while(step<n)
{
for(i=0; i<=n-2*step; i+=2*step)//注意，这里i<=n-2*step是因为要保证最后的一对step数组能够正确排序
{
mergeSort(nums, tmpNums, i, i+step, i+2*step-1);
}
if(i<n-step)
mergeSort(nums, tmpNums, i, i+step, n-1);//对于最后不能正好是一对step长度的情况，要单独处理，且保证最后一个参数为n-1
step*=2;
}

}

对于上面的函数merge,还可以写成下面的形式

void nMergeSort(vector<int>& nums){
vector<int> vec(nums.size());
int end=nums.size()-1;
for(int s=1; s<nums.size(); s<<=1){
for(int i=0; i+s<=end; i+=(2*s)){
if(i+2*s-1<=end)
merge(nums, vec, i, i+s, i+2*s-1);
else
merge(nums, vec, i, i+s, end);
}
}
}

递归实现方式：

void mergeSort(vector<int> & nums, vector<int> &tmpNums, int left, int right, int end)
{
int idx_left=left;
int idx_right=right;
int idx_total=left;
while(idx_left<right && idx_right<=end)
{
if(nums[idx_left]<=nums[idx_right])
tmpNums[idx_total++]=nums[idx_left++];
else
tmpNums[idx_total++]=nums[idx_right++];
}
while(idx_left<right)
tmpNums[idx_total++]=nums[idx_left++];
while(idx_right<=end)
tmpNums[idx_total++]=nums[idx_right++];

idx_left=left;
while(idx_left<=end)
{
nums[idx_left]=tmpNums[idx_left];
idx_left++;
}
}

void merge(vector<int> & nums, vector<int> & tmpNums, int left, int right)
{
if(left<right)
{
int mid=(left+right)/2;
merge(nums, tmpNums, left, mid);
merge(nums, tmpNums, mid+1, right);//注意mid+1
mergeSort(nums, tmpNums, left, mid+1, right);
}
}

2. 快速排序

void quikSort(vector<int>&nums, int low, int high){
if(low>=high)
return;
int key=nums[low];
int start=low, end=high;
while(start<end){//这里判断start<end不是<=
while(end>start && nums[end]>key)
end--;
nums[start]=nums[end];//赋值的操作方法

while(start<end && nums[start]<=key)
start++;
nums[end]=nums[start];//赋值的操作方法

}
nums[start]=key;//最后记得修改start下标对应的值
quikSort(nums, low, start-1);
quikSort(nums, start+1, high);
}

更高效的快排算法：

void mSwap(int & a, int & b){
int tmp=a;
a=b;
b=tmp;
}

void myQsort(vector<int> &nums, int low, int high){
if(low>=high)
return ;
int left=low, right=high;
int mid=(low+high)>>1;

int key=max(nums[low], nums[mid]);//增加计算中间节点的算法
key=min(nums[high], key);
if(key==nums[mid]){
mSwap(nums[low], nums[mid]);
}
else if(key==nums[high]){
mSwap(nums[low], nums[high]);
}

while(left<right){
while(left<right && key<nums[right]) right--;
nums[left]=nums[right];
while(left<right && nums[left]<=key) left++;
nums[right]=nums[left];
}
nums[left]=key;
myQsort(nums, low, left-1);
myQsort(nums, left+1, high);
}

3. 堆排序：

void adjust(int a[], int idx, int max){//堆调整函数，因为idx的左右两个子树都是大根堆，所以，可以保证每次调整后，整个堆也是大根堆
int left=2*idx+1;
int right=left+1;
int largest=idx;

if(left<max && a[left]>a[largest])
largest=left;
if(right<max && a[right]>a[largest])
largest=right;

if(largest!=idx){
int tmp=a[largest];
a[largest]=a[idx];
a[idx]=tmp;

adjust(a, largest, max);
}
}
//大根堆
void heapSort(int a[], int len){
for(int i=len/2-1; i>=0; --i){//初始化建堆时从下往上建堆
adjust(a, i, len);
}

int tmp;
for(int i=len-1; i>0; --i){//之后的调整都是从上往下建堆
tmp=a[i];//每次都是将根节点放到最后一个位置
a[i]=a[0];
a[0]=tmp;

adjust(a, 0, i);
}
}

另一种写法：

void swap(int &a, int &b){
int tmp=a;
a=b;
b=tmp;
}

//大根堆
void createHeap(int a[], int len){
int bigest;
for(int i=len/2; i>=0; i--){
bigest=i;
if(2*i<len){
if(a[2*i]>a[i])
bigest=2*i;
}
if(2*i+1<len){
if(a[2*i+1]>a[bigest])
bigest=2*i+1;
}
if(bigest==i)
continue;
else{
swap(a[bigest], a[i]);
}
}
}
//堆调整
void adjustHeap(int a[], int len){
int idx=0;
int bigest;
while(2*idx<len){
bigest=idx;
if(a[2*idx]>a[idx])
bigest=2*idx;
if(2*idx+1<len && a[2*idx+1]>a[bigest])
bigest=2*idx+1;
if(bigest==idx)
break;
swap(a[bigest], a[idx]);
idx=bigest;
}
}
//堆排序
void sortHeap(int a[], int len){
createHeap(a, len);

for(int i=len-1; i>=0; i--){
swap(a[i], a[0]);
adjustHeap(a, i);
}
}

一位大神的总结：

各种排序算法：http://blog.csdn.net/whuslei/article/details/6442755