【C语言算法】归并排序

思想

归并排序,是一种递归思想的排序方法,
2路归并指把两个有序序列组合为一个有序序列,
若初始序列无序,则看作是长度为1的多个有序序列,
把一个无序序列排序为有序序列的2路归并步骤如下:
1.设最小有序序列的长度为L,并设置初始L=1;
2.把整个序列分为若干组,每组长度为L;
3.使相邻的两个组归并为一个组,此时有序长度L为之前的两倍;
4.重复2-3步,直到L不小于待排序列的总长度.

核心算法

归并排序需要使用一个与原序列相同大小的辅助空间,用于存储归并后的序列.

// 2路归并排序,
// 输入:待排序列,序列1尺寸,序列2尺寸
// 输出:2路归并后的序列
void merge_2to1(int array[],int array_out[], int size1,int size2)
{
	int* in1 = array;
	int* in2 = &(array[size1]);
	int i = 0, j = 0,k=0;
	while (k < size1 + size2)
	{
		if (i == size1)
		{
			array_out[k] = in2[j];
			j++;
			k++;
			continue;
		}
		else if (j == size2)
		{
			array_out[k] = in1[i];
			i++;
			k++;
			continue;
		}
		if (in1[i] <= in2[j])
		{
			array_out[k] = in1[i];
			i++;
			k++;
		}
		else
		{
			array_out[k] = in2[j];
			j++;
			k++;
		}
	}
}

头文件

#include "stdlib.h"
#include "string.h"

递归调用

分组函数把待排序列居中分为两个子序列,通过递归的方式保证子序列有序,然后执行2路归并.

// 归并排序,递归分组
void merge_sort_self(int array[], int array_out[], int size)
{
	int cut_index;
	if (size > 1)
	{
		cut_index = size / 2;
		merge_sort_self(array, array_out, cut_index);
		merge_sort_self(&(array[cut_index]), &(array_out[cut_index]), size - cut_index);
		merge_2to1(array, array_out, cut_index, size - cut_index);
		memcpy(array, array_out, sizeof(int) * size);
	}
}

主函数主要申请一个与原序列相同大小的辅助空间,然后调用分组函数.

// 归并排序,递归调用
void merge_sort(int array[], int size)
{
	int* array_out = calloc(size, sizeof(int));
	if (size > 0)
	{
		merge_sort_self(array, array_out, size);
	}
	free(array_out);
}

非递归调用

分组函数根据指定的分组大小把待排序列分为若干组,并假设每组数据都是有序的,然后对相邻组执行2路归并.

// 把序列分为若干组,两两归并
void merge_sort_group(int array[], int array_out[], int size, int group_size)
{
	int group_num = size / group_size;

	// 如果组数为奇数,先处理末尾
	if (group_num & 1)
	{
		// 和之后有不足sroup_size 的部分归并
		merge_2to1(&array[(group_num - 1) * group_size],
			&array_out[(group_num - 1) * group_size],
			group_size, size % group_size);
		group_num--;
	}
	else if (size % group_size)
	{
		// 剩余部分直接复制到输出
		merge_2to1(&array[(group_num) * group_size],
			&array_out[(group_num) * group_size],
			size % group_size,0 );
	}
	for (int i = 0; i < group_num;i+=2)
	{
		merge_2to1(&array[i * group_size], &array_out[i * group_size],
			group_size, group_size);
	}
}

主函数首先申请一个与待排序列相同大小的辅助空间,然后从1开始设置组的长度,调用分组函数.

// 归并排序,非递归调用
void merge_sort_non(int array[], int size)
{
	int* array_out = calloc(size, sizeof(int));
	int* out=array_out, * in=array,*temp;

	for (int i = 1; i < size; i *= 2)
	{
		merge_sort_group(in, out, size, i);
		temp = in;
		in = out;
		out = temp;
	}
	if (in != array)
		memcpy(array, in, sizeof(int) * size);
	free(array_out);
}