排序|归并排序|递归|非递归|计数排序(C)-优快云博客

归并排序

如果数组的左半区间有序，右半区间有序，可以直接进行归并

基本思想

快排是一种前序，归并是后序
每次取小尾插
在这里插入图片描述

void _MergeSort(int* a, int* tmp, int begin, int end)
{
	if (end <= begin)
		return;

	int mid = (end + begin) / 2;
	//[begin, mid], [mid+1, end]
	_MergeSort(a, tmp, begin, mid);
	_MergeSort(a, tmp, mid+1, end);

	//归并到tmp数组，拷贝回去
	int begin1 = begin, end1 = mid;
	int begin2 = mid+1, end2 = end;
	int index = begin;
	while (begin1 <= end1 && begin2 <= end2)
	{
		if (a[begin1] < a[begin2])
		{
			tmp[index++] = a[begin1++];
		}
		else
		{
			tmp[index++] = a[begin2++];
		}
	}

	while (begin1 <= end1)
	{
		tmp[index++] = a[begin1++];
	}

	while (begin2 <= end2)
	{
		tmp[index++] = a[begin2++];
	}

	//拷贝回原数组
	memcpy(a + begin, tmp + begin, (end - begin + 1)*sizeof(int));
}

void MergeSort(int* a, int n)
{
	int* tmp = (int*)malloc(sizeof(int) * n);
	if (tmp == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}

	_MergeSort(a, tmp, 0, n - 1);

	free(tmp);
}

创建tmp临时数组来存放分解出来的数据
perror判断是否malloc成功
调用归并排序
释放tmp空间
如果右边界小于等于左边界，归并返回
计算出mid，将整个区间分为左区间和右区间
分别对左右区间进行归并排序
同时遍历左右区间，选择小的插入到tmp临时数组里
再将tmp数组的内容拷贝到原数组

特性总结

归并的缺点在于需要O(N)的空间复杂度，归并排序的思考更多的是解决在磁盘中的外排序问题。
时间复杂度： $O(N\cdot \log_{2}N)$
空间复杂度： $O (N)$
稳定性：稳定

非递归

后序用栈很难控制
跳脱模拟递归的过程，模拟斐波那契数列
一一归并，两两归并，四四归并，每次归并完要拷贝回原数组
从递归往回推的过程

void MergeSortNonR(int* a, int n)
{
	int gap = 1;
	while (gap < n)
	{
		for (int i = 0; i < n; i += 2*gap)
		{
			int begin1 = i, end1 = i + gap - 1;
			int begin2 = i+gap, end2 = i + 2*gap - 1;

			//如果第二组不存在，这一组不用归并了
			if (begin2 >= n)
			{
				break;
			}

			//如果第二组的右边界越界了，修正一下
			if (end2 >= n)
			{
				end2 = n - 1;
			}

			int index = i;
			while (begin1 <= end1 && begin2 <= end2)
			{
				if (a[begin1] <= a[begin2])
				{
					tmp[index++] = a[begin1++];
				}
				else
				{
					tmp[index++] = a[begin2++];
				}
			}
		
			while (begin1 <= end1)
			{
				tmp[index++] = a[begin1++];
			}
		
			while (begin2 <= end2)
			{
				tmp[index++] = a[begin2++];
			}
	
			memcpy(a + i, tmp + i, (end2-i+1) * sizeof(int));
		}

		gap *= 2;
	}

	free(tmp);
}

用gap来表示区间的大小
第一轮一一归并，gap为1，之后每一轮gap++
通过gap计算出来的左右两个区间，右区间有可能越界，需要进行控制
在归并之前进行判断，如果右边的组不存在，这一轮就不用归并了，直接返回
如果右边的组的右边界越界了，修正一下

非比较排序

计数排序

计数排序又称为鸽巢原理，是对哈希直接定址法的变形应用。操作步骤：

统计相同元素出现次数
根据统计的结果将序列回收到原来的序列中
统计每个数据出现的次数
每个值是多少，就在对应位置++
映射，每个数的值和它的位置建立关系
分绝对映射和相对映射
绝对映射：数是几就映射哪个位置
相对映射：数的范围是多少，就映射多少个位置，适合数据范围相对集中

void CountSort(int* a, int n)
{
	int min = a[0], max = a[0];
	for (size_t i = 0; i < n; i++)
	{
		if (a[i] < min)
			min = a[i];

		if (a[i] > max)
			max = a[i];
	}

	int range = max - min + 1;
	int* count = (int*)malloc(sizeof(int) * range);
	if (count == NULL)
	{
		perror("malloc fail");
		return;
	}	
	memset(count, 0, sizeof(int) * range);

	//统计数据出现次数
	for (int i = 0; i < n; i++)
	{
		count[a[i] - min]++;
	}

	//排序
	int j = 0;
	for (int i = 0; i < range; i++)
	{
		while (count[i]--)
		{
			a[j++] = i + min;
		}
	}
}