各种排序算法实现

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