1.常见排序

在这里插入图片描述

2.归并排序

归并排序（MERGE-SORT）是建立在归并操作上的一种有效的排序算法,该算法是采用分治法（Divide andConquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。归并排序核心步骤：

在这里插入图片描述

2.1归并排序基本思想

归并排序是一种基于分治思想的排序算法。它将待排序的序列分成若干个子序列，每个子序列都是有序的，然后再将这些有序的子序列合并成一个大的有序序列。具体的实现过程通常采用递归的方法。

归并排序的基本思想是先将待排序序列划分成若干个子序列，每个子序列都是有序的，然后再将这些子序列两两合并，直至最终只剩下一个有序的序列，即为排序后的序列。

归并排序的时间复杂度为O(nlogn)，具有稳定性，适用于对链表等非顺序存储的数据结构进行排序。

在这里插入图片描述

2.2归并排序的实现

归并排序通常使用递归来实现，实现过程可以分为两个主要步骤：

（1）分割：将待排序的序列递归地分成两个子序列，直到每个子序列中只有一个元素为止。

（2）合并：将已经有序的两个子序列合并成一个有序序列。

实现归并排序：

归并排序需要一个临时的空间来进行分割元素的合并，所有我们创建一个和原数组一样大小的临时空间tmp，为了方便空间的使用，我们建立一个归并排序函数MergeSort的子函数_MergeSort。

函数MergeSort是对_MergeSort的调用，在排序前会先申请一个临时数组tmp，然后将整个数组进行归并排序，最后释放临时数组的内存空间。

函数_MergeSort实现了归并排序的递归过程。参数a是待排序的数组，begin和end表示要排序的子数组的起始下标和结束下标，tmp是用来暂存排序结果的临时数组。函数首先将子数组分成两半，然后递归地对左右子数组进行排序，排序完成后再将两个有序子数组合并成一个有序数组。

这个过程中使用了三个指针：begin1和end1指向左子数组的起始和结束下标，begin2和end2指向右子数组的起始和结束下标，i指向存放排序结果的临时数组中的当前位置。在合并的过程中，依次比较左右子数组中的元素，将较小的元素存入临时数组中，直到任一子数组中的元素全部比较完毕，然后将另一个子数组中的所有元素直接存入临时数组中，最后将临时数组中的元素复制回原数组的相应位置。

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

	int mid = (begin + end) / 2;
	// [begin, mid] [mid+1,end]，子区间递归排序
	_MergeSort(a, begin, mid, tmp);
	_MergeSort(a, mid+1, end, tmp);

	// [begin, mid] [mid+1,end]归并
	int begin1 = begin, end1 = mid;
	int begin2 = mid+1, end2 = end;
	int i = begin;
	while (begin1 <= end1 && begin2 <= end2)
	{
		if (a[begin1] < a[begin2])
		{
			tmp[i++] = a[begin1++];
		}
		else
		{
			tmp[i++] = a[begin2++];
		}
	}

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

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

	memcpy(a + begin, tmp + begin, sizeof(int) * (end - begin + 1));
}

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

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

	free(tmp);
}

归并排序的非递归实现：

归并排序通过这样的循环非递归实现，可以避免递归带来的额外计算和栈空间的消耗，使归并排序更为高效。

函数MergeSortNonR需要传入一个待排序的数组a和数组的长度n作为参数。首先申请一个大小为n的临时数组tmp，用于排序过程中存储临时结果。然后，MergeSortNonR使用一个循环，每次将待排序的序列分成大小为2×gap的小数组，并将相邻的两个小数组合并成一个有序数组。

此后，将gap的大小翻倍，继续合并两个有序数组，直到合并后的数组大小为原数组大小为止。在每次合并的过程中，依次比较左右两个小数组中的元素，将较小的元素依次存到临时数组tmp中。

void MergeSortNonR(int* a, int n)
{
	int* tmp = (int*)malloc(sizeof(int) * n);
	if (tmp == NULL)
	{
		perror("malloc fail\n");
		return;
	}

	int gap = 1;
	while (gap < n)
	{
		for (int i = 0; i < n; i += 2 * gap)
		{
			// [begin1,end1][begin2, end2]
			int begin1 = i, end1 = i + gap - 1;
			int begin2 = i + gap, end2 = i + 2 * gap - 1;
			int j = i;
			while (begin1 <= end1 && begin2 <= end2)
			{
				if (a[begin1] < a[begin2])
				{
					tmp[j++] = a[begin1++];
				}
				else
				{
					tmp[j++] = a[begin2++];
				}
			}

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

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

			// 拷贝
		}
		gap *= 2;
	}

	free(tmp);
}

2.3归并排序特性总结

（1）归并的缺点在于需要O(N)的空间复杂度，归并排序的思考更多的是解决在磁盘中的外排序问题。

（2）时间复杂度：O(N*logN)

（3）空间复杂度：O(N)

（4）稳定性：稳定

3.各大排序复杂度和稳定性

在这里插入图片描述

排序方法	平均情况	最好情况	最坏情况	辅助空间	稳定性
冒泡排序	O(n²)	O(n)	O(n²)	O(1)	稳定
简单选择排序	O(n²)	O(n²)	O(n²)	O(1)	不稳定
直接插入排序	O(n²)	O(n)	O(n²)	O(1)	稳定
希尔排序	O(nlogn)~O(n²)	O(n^1.3)	O(n²)	O(1)	不稳定
堆排序	O(nlogn)	O(nlogn)	O(nlogn)	O(1)	不稳定
归并排序	O(nlogn)	O(nlogn)	O(nlogn)	O(n)	稳定
快速排序	O(nlogn)	O(nlogn)	O(n²)	O(logn)~O(n)	不稳定