利用分治法的排序算法比较

1.快速排序

代码：

int partition(int a[],int p,int r)
{
	int key = a[r];
	int i = p;
	int j = p;
	int t;
	while(j<r)
	{
		if(a[j] <= key)
		{
			
			t = a[i];
			a[i] = a[j];
			a[j] = t;
			i++;
		}
		j++;
	}
	t = a[i];
	a[i] = a[r];
	a[r] = t;
	return i;
} 
void quick(int a[],int p, int r)
{
	if(p<r)
	{
		int i = partition(a,p,r);
		quick(a,p,i-1);
		quick(a,i+1,r);
	}
}

快速排序的核心就是一个关键值，先确定一个key值，然后遍历整个数组，让数组分为两个部分，左边部分小于key值，右边部分大于key值（两部分元素数目可能不同，实际上经常不同）；

然后就是递归该做的事了。

2.归并排序

排序2个元素的数组，比排序4个元素的数组简单吧，排序4个元素的数组，比排序八个元素的数组简单吧。归并排序干的就是这类的事情。将数组一步一步的变小，再合并；

void merge(int list1[], int list1Size,int list2[], int list2Size)
{
	int *list;
	int i=0,j=0,k=0;
	list = (int *)malloc(sizeof(int)*(list1Size+list2Size));
	while(i<list1Size && j<list2Size)
		list[k++] =  list1[i]<list2[j]?list1[i++]:list2[j++];
	while(i<list1Size)
		list[k++] = list1[i++];
	while(j<list2Size)
		list[k++] = list2[j++];
	i=-1; 
	while(++i<k)
	{
		list1[i] = list[i];
	}
	    
	free(list);
}
void mergesort(int list[],int listsize)
{
	
	if(listsize > 1)
	{
		int i,j;
		int *list1,*list2;
		i = listsize/2;
		j = listsize -i;
		list1 = list;
		list2 = list+i;
		mergesort(list1,i);
		mergesort(list2,j);
		merge(list1,i,list2,j);
	}
}

3.堆排序

堆排序利用了二叉树的性质，这里得提到一个性质最大堆，最大堆就是根节点大于等于 所有子节点。

先将整个数组处理为一个最大堆，然后交换首尾元素，再将第0位到第n-1位，处理为最大堆，再交换0号元素和n-1号元素。一直处理到0位；

void Heap_MAX(int a[], int i, int length)
{
	int nchild = 2*i+1;
	int ntemp;
	for(;2*i+1<length;i = nchild)
	{
		nchild = 2*i+1;
		if(nchild<length-1 && a[nchild] <a[nchild+1] )
		{
			nchild++;
		} 
		if(a[nchild]>a[i])
		{
			ntemp = a[nchild];
			a[nchild] = a[i];
			a[i] = ntemp;
		}
		else
		{
			break;
		}
	} 
	
}

void heapsort(int a[],int length)
{
	int i,temp;
	for(i=length/2-1;i>=0;i--)
	{
		Heap_MAX(a,i,length);
	}
	for(i=length-1;i>0;i--)
	{
		temp = a[i];
		a[i] = a[0];
		a[0] = temp;
		Heap_MAX(a,0,i);
	}
}