借鉴一下别人写的归并排序

归并排序是利用了分治算法的一种排序！

分解： 分解待排序的n个元素的序列为两个n/2个元素的子序列；

解决：使用归并排序递归排序两个子序列；

合并：合并两个已排序的子序列排序完毕。

归并排序的时间复杂度是O(nlgn);

虽然我自己可以很轻松的写出归并排序，但我还是引用了别人写的代码，这是清华大学计算机系的将《算法导论》中2.3章节的归并排序由伪代码用c语言实现的。

今天无意间看到的，写得真的非常的精彩，值得一看！

	#include<stdio.h>
	#include<stdlib.h>
	#include<string.h>
	#include<limits.h>
	#include<time.h>

	void merge(void *base,size_t elem_size,size_t left,size_t middle,
			   size_t right,void *max,int(*comp)(const void*,const void*),void *buf)
	{
		char * cbase = (char*)base;
		char * cbuf	 = (char*)buf;
		size_t left_length = middle - left + 1;
		size_t right_length = right - middle;
		char * left_buf = cbuf;
		char * right_buf = &cbuf[(left_length + 1)*elem_size];

		for (int i = 0;i<left_length;i++)
		{
			memcpy(&left_buf[i*elem_size],&cbase[(left + i)* elem_size],elem_size);
		}
		memcpy(&left_buf[left_length*elem_size],max,elem_size);

		for (int i=0;i<right_length;i++)
		{
			memcpy(&right_buf[i*elem_size],&cbase[(middle+1+i)*elem_size],elem_size);
		}
		memcpy(&right_buf[right_length*elem_size],max,elem_size);

		for (int k = left,i=0,j=0;k<=right;k++)
		{
			if(comp(&left_buf[i*elem_size],&right_buf[j*elem_size]) <= 0)
			{
				memcpy(&cbase[k*elem_size],&left_buf[i*elem_size],elem_size);
				i++;
			}
			else
			{
				memcpy(&cbase[k*elem_size],&right_buf[j*elem_size],elem_size);
				j++;
			}
		}
	}

	void merge_sort_buf(void * base,size_t elem_size,size_t left,size_t right,
						void *max,int(*comp)(const void*,const void *),void *buf)
	{
		if(left<right)
		{
			size_t middle = (left + right)/2;
			merge_sort_buf(base,elem_size,left,middle,max,comp,buf);
			merge_sort_buf(base,elem_size,middle+1,right,max,comp,buf);
			merge(base,elem_size,left,middle,right,max,comp,buf);
		}
	}

	void merge_sort(void * base,size_t elem_size,size_t left,size_t right,
					void *max,int (*comp)(const void *,const void *))
	{
		if (left>=right)
		{
			return;
		}
		size_t length = right -left + 1; /*数组长度*/
		char *buf = (char *)malloc((length + 2) * elem_size);	/*要存放两个标兵，所以+2*/
		merge_sort_buf(base,elem_size,left,right,max,comp,buf);
		free(buf);
	}

	void swap(void *a,void *b,size_t elem_size)
	{
		if(a == NULL || b == NULL || a==b)
		{
			return;
		}
		char *temp = (char *)malloc(sizeof(elem_size));
		memcpy(temp,a,elem_size);
		memcpy(a,b,elem_size);
		memcpy(b,temp,elem_size);
		free(temp);
	}

	void randomized_in_place(void * array,size_t elem_size,int n)
	{
		char * c_array = (char *)array;
		for (int i = 0;i<n;i++)
		{
			int index = rand()%(n-i) + i;
			swap(&c_array[i*elem_size],&c_array[index * elem_size],elem_size);
		}
	}

	void print_array(int a[],int n)
	{
		for (int i=0;i<n;i++)
		{
			printf("%d ",a[i]);
		}
		printf("\n");
	}

	int cmp_int(const void *p1,const void * p2)
	{
		const int * pa = (int *)p1;
		const int * pb = (int *)p2;
		if(*pa < *pb)
		{
			return -1;
		}
		if(*pa == *pb)
		{
			return 0;
		}
		return 1;
	}

	int main(void)
	{
		srand((unsigned)time(NULL));
		int a[10];
		for (int i=0;i<10;i++)
		{
			a[i] = i;
		}
		randomized_in_place(a,sizeof(int),10);
		printf("排序前：\n");
		print_array(a,10);
		int max_int = INT_MAX;
		merge_sort(a,sizeof(int),0,9,&max_int,cmp_int);
		printf("排序后：\n");
		print_array(a,10);
		system("pause");
		return 0;
	}