聊聊效率较高的几种常用排序算法

1、快速排序：主要思想是找个基准，将数据分成两半，不断迭代排序。注意所有元素都比基准大、或者都比基准小的情况。不稳定，交换位置时会造成相等元素调换前后位置。

#include <iostream>
 using namespace std;

void quickSort(int *a, int left, int right)
{
    if(left >= right)/*如果左边索引大于或者等于右边的索引就代表已经整理完成一个组了*/
    {
        return ;
    }
    
    int key = a[left];  //1、找基准元素，假设是左边第一个
    int i = left+1;
    int j = right;
    int tmp = 0;
     
    while(i < j)
    {
        while(i <= j && key <= a[j]) //2、从右往左找，找到第一个比key小的停止
        {
            j--;/*向前寻找*/
        }
        while(i < j && key >= a[i]) //3、从左往右找，找到第一个比key大的停止。小心i越界
        {
            i++;
        }
        if (i < j)
        {
            tmp = a[i];                 //4、交换，比key小的移动到左边，比key大的移动到右边
            a[i] = a[j]; 
            a[j] = tmp;
        }
       
    }
    if (i == j && key > a[i])      //5、此时，i、j左边的（如果有）全比key小，右边（如果）全比key大；可能key右边全部比key大，此时不交换
    {
        a[left] = a[i];  
        a[i] = key; 
    }
     
    quickSort(a, left, i - 1);/*最后用同样的方式对分出来的左边的小组进行同上的做法*/
    quickSort(a, j + 1, right);/*用同样的方式对分出来的右边的小组进行同上的做法*/
}

int main()
{
    int a[] = {6,5,4,3};
    quickSort(a, 0, sizeof(a) / sizeof(a[0]) - 1);
    for(int i = 0; i < sizeof(a) / sizeof(a[0]); i++)
    {
        cout << a[i] << " ";
    }
    cout << endl;    
    return 0;
}

#include <iostream>
#include <stdio.h>
void swap(int *a, int*b)
{
	int tmp = *a;
	*a = *b;
	*b = tmp;
}

int quickSort(int a[], int low, int high)
{
	if(low >= high)
		return 0;
	int key = a[low];
	int i=low, j=high;
	while (i < j)
	{
		while(i<j && a[j] >= key)
			--j;
		swap(&a[i], &a[j]);
		while(i<j && a[i] <=key)
			++i;
		swap(&a[i], &a[j]);
	}
	/*
	for(int k=0; k<10; ++k)
		std::cout<<a[k]<<" ";
	std::cout<<std::endl;
	std::cout<<"low:"<<low<<",i:"<<i<<",j"<<j<<",high:"<<high<<std::endl;
	getchar();
	*/
	quickSort(a, low, j-1);
	quickSort(a, j+1, high);
	return 0;
}		

int main()
{
	int a[] = {9,6,7,4,3,11,12,44,8,5};
	int len = sizeof(a)/sizeof(a[0]);
	quickSort(a, 0, len-1);
	for(int i=0; i<len-1; ++i)
		std::cout<<a[i]<<" "<<std::endl;
	return 0;
}

#include <iostream>
#include <stdio.h>

int quickSort(int a[], int low, int high)
{
	if(low >= high)
		return 0;
	int key = a[low];
	int i=low, j=high;
	while (i < j)
	{
		while(i<j && a[j] >= key)
			--j;
	//	swap(&a[i], &a[j]);
		a[i] = a[j];
		while(i<j && a[i] <=key)
			++i;
	//	swap(&a[i], &a[j]);
		a[j] = a[i];
	}
	a[i] = key;
	/*
	for(int k=0; k<10; ++k)
		std::cout<<a[k]<<" ";
	std::cout<<std::endl;
	std::cout<<"low:"<<low<<",i:"<<i<<",j"<<j<<",high:"<<high<<std::endl;
	getchar();
	*/
	quickSort(a, low, j-1);
	quickSort(a, j+1, high);
	return 0;
}		

int main()
{
	int a[] = {9,6,7,4,3,11,12,44,8,5};
	int len = sizeof(a)/sizeof(a[0]);
	quickSort(a, 0, len-1);
	for(int i=0; i<len-1; ++i)
		std::cout<<a[i]<<" "<<std::endl;
	return 0;
}

2、归并排序：从中间一分为二，左右边分别排序，然后合并。稳定，相等元素不会调换位置。

#include <iostream>
using namespace std;

int mergeArray(int src[], int first, int mid, int end, int tmp[])
{
	if (first >= end)
	{
		return 0;
	}
	int i = first, j = mid+1;
	int k = 0;
	while (i<=mid && j<=end)
	{
		if (src[i] < src[j])
			tmp[k++] = src[i++];
		else
			tmp[k++] = src[j++];
	}
	while (i <= mid)
		tmp[k++] = src[i++];
	while (j <= end)
		tmp[k++] = src[j++];

	for (int i = 0; i < k; ++i)
	{
		src[first+i] = tmp[i];
	}
	return 0;
}

int mergeSort(int src[], int first, int end, int tmp[])
{
	if (first >= end)
	{
		return 0;
	}
	int mid = (first+end)/2;
	mergeSort(src, first, mid, tmp); //左边排序
	mergeSort(src, mid+1, end, tmp); //右边排序
	mergeArray(src, first, mid, end, tmp);	//合并
	return 0;
}

int main(int argc, char const *argv[])
{
	int a[] = {3,4,5,1,9,7,8};
	int tmp[7];
	mergeSort(a, 0, 6, tmp);
	for (int i = 0; i < 7; ++i)
	{
		cout << tmp[i] <<" ";
	}
	cout << endl;

	return 0;
}

3、堆排序：第一步建堆从倒数第一个非叶子节点调整（假设是最大堆，堆顶就是最大元素）；第二步不断取出堆顶，将最后一个元素移至堆顶，重新调整。用数组可约内存。

不稳定，当最后一个元素调整到堆顶时相等的元素就会调换位置。

#include <iostream>
using namespace std;
// 二叉树的基本操作
#define PARENT(i) ((i)>>1)
#define LEFTCHILD(i) ((i)<<1)
#define RIGHTCHILD(i) (((i)<<1)+1)


void printArray(int * array)
{
    if(array == NULL)
        return;
    int arraySize = array[0];
    for(int k = 1 ; k <= arraySize ; ++k)
    {
        cout<<array[k]<<" ";
    }
    cout<<endl;
}
/**
 * 交换数组两个位置的元素
 */
void exchange(int * array , int pos1 , int pos2)
{
    if(array == NULL)
        return;
    int temp = array[pos1];
    array[pos1] = array[pos2];
    array[pos2] = temp;
}
/**
 * 维护最大堆的性质
 * @param array 传入的堆数组，注意此数组是从位置1开始，位置0存放堆的大小
 * @param pos   需要更新的位置
 */
void maxHeapify(int * array , int pos)
{
    if(array == NULL)
        return;
    if(pos > array[0])// 超出堆的大小
        return;
    int leftChild = LEFTCHILD(pos);
    int rightChild = RIGHTCHILD(pos);
    // 找到最大的那个
    int maxPos = pos;
    if(leftChild <= array[0] && array[leftChild] > array[pos] )
        maxPos = leftChild;
    if(rightChild <= array[0] && array[rightChild] > array[maxPos])
        maxPos = rightChild;
    // 交换父节点与子节点
    if(maxPos != pos)
    {
        exchange(array , maxPos , pos);
        maxHeapify(array , maxPos);
    }
}

/**
 * 堆排序
 * @param array 传入需要排序的数组,注意此数组是从位置1开始，位置0存放数组数组元素的个数   
 */
void heapSort(int * array)
{
    if(array == NULL)
        return;
    // 首先构建最大堆
    cout << "build heap..." << endl;
    cout << "element num:" << array[0] << endl; //array[0]表示节点个数
    for(int k = array[0]/2 ; k >=1 ; --k) //从最后一个非叶子节点开始调整堆
    {
        maxHeapify(array , k);
    }
    int arraySize = array[0];   //取出堆顶后，堆的大小是要变化的
    //下面开始每次都取出堆里面堆顶位置的元素,再次进行堆性质维护
    for(int k = array[0] ; k >=2 ; --k)
    {
        exchange(array , 1, k); //最大值移动最后面，不需要一个int内存空间
        array[0] -= 1;
        maxHeapify(array , 1);
    }
    array[0] = arraySize;
}

int main(int argc, char const *argv[])
{
    int array[]={0,4,1,3,2,16,9,10,14,8,7};
    array[0] = sizeof(array)/sizeof(int) - 1;
    heapSort(array);
    printArray(array);
    return 0;
}

下面链接动画不错：

http://www.cnblogs.com/eniac12/p/5329396.html

http://www.cnblogs.com/jztan/p/5878630.html