归并排序是利用了分治算法的一种排序!
分解: 分解待排序的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;
}