本文目录

一、排序概念
二、插入排序
- 1.插入排序的基本思想
- 2.算法实现
- 3.时间复杂度分析
三、希尔排序
- 1. 希尔排序的思想
- 2.希尔排序的代码实现
- 3.希尔排序和插入排序的性能测试比较
- 4.希尔排序的时间复杂度
四、直接选择排序
- 1.基本思想
- 2.直接选择排序的步骤
- 3.直接选择排序的代码实现
- 4.直接选择排序的特性
五、堆排序
- 1.堆排序的概念
- 2.堆排序的实现
- 3.堆排序的特性
六、冒泡排序
- 1.冒泡排序的思想
- 2. 冒泡排序的实现
七、排序性能测试

一、排序概念

所谓排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。
排序在生活中也是具有十分普遍的应用。

二、插入排序

1.插入排序的基本思想

把待排序的记录按其关键码值的大小逐个插入到一个已经排好序的有序序列中，直到所有的记录插入完为止，得到一个新的有序序列。

实际中我们玩扑克牌时，就用了插入排序的思想

2.算法实现

如上图所示就是插入排序算法的模拟实现动图

为了使用C语言来实现，我们可以这样理解插入排序：
1.将原来的[0,end]这个区间中的树视为有序，我们一开始可以将这样end设置为0，一个区间只有一个数据当然可以认为始有序的。
2.将数组的第end+1位置的数据记录成tmp，从后往前依次比较，如果这个数小于前面的数据，则直接让前面这个数据往后移动一位。一直循环，直到前面的数据都比tmp小，或者end已经小于0了，也就是说，tmp就是最小的数据。
3.直接将tmp插入到当前的end+1位置。此时就完成了一个数据的插入
4.让end从0持续增加到n-2，也就是让后面的每一个数据都进行一次插入，增加到n-2的原因是，数组总共有n个元素，最后一个元素的下标始n-1，但是最后一次是我们将这个元素插入到[0,n-2]这个区间中，所以最end需要改变到n-2即可。

具体代码如下所示

//插入排序
void InsertSort(int* a, int n)
{
	for (int i = 0; i < n - 1; i++)
	{
		int end = i;
		int tmp = a[end + 1];
		while (end >= 0)
		{
			if (tmp < a[end])
			{
				a[end + 1] = a[end];
				end--;
			}
			else
			{
				break;
			}
			a[end + 1] = tmp;
		}
	}
}

3.时间复杂度分析

不难看出：
最好情况是顺序的情况，这样就只有最外层的循环了。时间复杂度为O(N)
最坏情况是逆序的情况，这样就是一个等差数列的情况。时间复杂度为O(N^2)

直接插入排序的特性总结：

元素集合越接近有序，直接插入排序算法的时间效率越高
时间复杂度：O(N^2)
空间复杂度：O(1)，它是一种稳定的排序算法
稳定性：稳定

三、希尔排序

1. 希尔排序的思想

希尔排序法又称缩小增量法。希尔排序法的基本思想是：先选定一个整数，把待排序文件中所有记录分成个组，所有距离为的记录分在同一组内，并对每一组内的记录进行排序。然后，取，重复上述分组和排序的工作。当到达1时，所有记录在统一组内排好序。

简单来说呢，就是先将原来混来的数组进行预排序，预排序的方式是通过间隔为gap的数据给认为是在一组中，然后再这一组中进行直接插入排序。同时我们有两种方式进行预排序，一种是一组排完排另外一组，一种是同时排序
我们也不难发现如果gap越大，也就代表着一组中相邻元素越远。组的个数就越多。大的数就能越快的跳到后面。因为一次可以跳跃gap步，但是数据也就越不接近有序
而如果gap越小的话，相邻元素越近。组的个数越少。大的数越不容易跳到后面，因为组少，每一组的元素就多了。一次跳的就少了。但是数据也更加接近有序
对于这个gap我们可以让他跟数组元素个数进行相互关联。然后让gap逐渐由大到小减小。对于gap的最优解，一般有两种方式，一种是让gap每次除2，另外一种是让gap除3然后+1，加一的目的是为了防止当gap为2的时候，gap就变为了0，不会变成1。也就是不会变成有序数组了。

2.希尔排序的代码实现

//希尔排序
void ShellSort(int* a, int n)
{
	int gap = n;
	while (gap > 1)
	{
		gap /= 2;
		for (int i = 0; i < n - gap; i++)
		{
			int end = i;
			int tmp = a[end + gap];
			while (end >= 0)
			{
				if (a[end] > tmp)
				{
					a[end + gap] = a[end];
					end -= gap;
				}
				else
				{
					break;
				}
			}
			a[end + gap] = tmp;
		}
		Print(a, n);
	}
}

3.希尔排序和插入排序的性能测试比较

我们可以使用这段代码来进行测试

void TestOP()
{
	srand(time(0));
	const int N = 100000;
	int* a1 = (int*)malloc(sizeof(int) * N);
	int* a2 = (int*)malloc(sizeof(int) * N);
	//int* a3 = (int*)malloc(sizeof(int) * N);
	//int* a4 = (int*)malloc(sizeof(int) * N);
	//int* a5 = (int*)malloc(sizeof(int) * N);
	//int* a6 = (int*)malloc(sizeof(int) * N);
	for (int i = 0; i < N; ++i)
	{
		a1[i] = rand();
		a2[i] = a1[i];
		//a3[i] = a1[i];
		//a4[i] = a1[i];
		//a5[i] = a1[i];
		//a6[i] = a1[i];
	}
	int begin1 = clock();
	InsertSort(a1, N);
	int end1 = clock();
	int begin2 = clock();
	ShellSort(a2, N);
	int end2 = clock();
	//int begin3 = clock();
	//SelectSort(a3, N);
	//int end3 = clock();
	//int begin4 = clock();
	//HeapSort(a4, N);
	//int end4 = clock();
	//int begin5 = clock();
	//QuickSort(a5, 0, N - 1);
	//int end5 = clock();
	//int begin6 = clock();
	//MergeSort(a6, N);
	//int end6 = clock();
	printf("InsertSort:%d\n", end1 - begin1);
	printf("ShellSort:%d\n", end2 - begin2);
	//printf("SelectSort:%d\n", end3 - begin3);
	//printf("HeapSort:%d\n", end4 - begin4);
	//printf("QuickSort:%d\n", end5 - begin5);
	//printf("MergeSort:%d\n", end6 - begin6);
	free(a1);
	free(a2);
	//free(a3);
	//free(a4);
	//free(a5);
	//free(a6);
}

最终运行结果为
希尔排序和插入排序性能测试比较

可见希尔排序的性能远高于插入排序

4.希尔排序的时间复杂度

先说结论，希尔排序的时间复杂度为O(N*logN)

对于希尔排序的时间复杂度计算，其实是比较复杂的。如果要精确的算出来，需要很强的数学功底。但是我们可以简单的进行计算。

首先希尔排序的是由三层循环组成，我们千万不能想当然的认为三层循环时间复杂度就是立方级
我们首先看希尔排序的最外层循环，他是由gap来控制的，gap每次除以2或者每次除以3+1，我们就以除以2来举例，gap从N开始，每次除以2，这其实就类似于二分法。所以时间复杂度为O(logN)
然后再看内层的两个循环。这两个循环其实是相互牵制的。我们先看临界条件
最开始的时候，gap非常大。为n/2，这就导致了中间的循环为O(N)，但是由于gap很大。也就是说每一组中相邻元素的间隔很大。组的个数很多。这就导致了每一组的元素很少。他们的移动次数是非常之少的。只有常数次。所以最开始的时候，内部的两层循环时间复杂度可以近似认为O(N)
在末尾的时候，gap很小，已经达到了1，这时候就是直接插入排序，中间层的循环还是O(N)，但是由于上面的很多次预排序。已经使得数组十分接近有序了。所以每一次的移动次数很少。这就导致了总的时间复杂度仍然为O(N)
上面是两个极端情况。对于中间的情况，我们经过一些测算，不难发现是略高于两端的，但是时间复杂度仍然属于O(N)级别。所以中间和内存循环的总时间复杂度类似于下图的模型

经过上面的分析，我们得到了希尔排序的时间复杂度为O(NlogN)，但是实际上是稍微比 NlogN大一些
但是也有一个结论说：希尔排序的时间复杂度为O(N^1.3)，该数据来源于《数据结构(C语言版)》— 严蔚敏

四、直接选择排序

1.基本思想

每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完。
或者我们也可以一次性选好最大和最小的两个元素，然后与两边分别交换，但是这样的话，需要注意的是，如果先交换最小的与左边的，那么当最大正好就是最左边的时候，最大值就被修改了，需要修正最大值下标，最大值下标恰好就是最小值下标

2.直接选择排序的步骤

1.在元素集合array[i]–array[n-1]中选择关键码最大(小)的数据元素
2.若它不是这组元素中的最后一个(第一个)元素，则将它与这组元素中的最后一个（第一个）元素交换
3.在剩余的array[i]–array[n-2]（array[i+1]–array[n-1]）集合中，重复上述步骤，直到集合剩余1个元素

3.直接选择排序的代码实现

//直接选择排序
void SelectSort(int* a, int n)
{
	int left = 0;
	int right = n - 1;
	while (left < right)
	{
		int mini = left;
		int maxi = left;
		for (int i = left + 1; i <= right; i++)
		{
			if (a[i] < a[mini])
			{
				mini = i;
			}
			if (a[i] > a[maxi])
			{
				maxi = i;
			}
		}
		Swap(&a[mini], &a[left]);
		if (maxi == left)
		{
			maxi = mini;
		}
		Swap(&a[maxi], &a[right]);
		right--;
		left++;
	}
}

4.直接选择排序的特性

直接选择排序思考非常好理解，但是效率不是很好。实际中很少使用
时间复杂度：O(N²)，最好与最坏都是O(N²)。
空间复杂度：O(1)
稳定性：不稳定

五、堆排序

1.堆排序的概念

堆排序(Heapsort)是指利用堆积树（堆）这种数据结构所设计的一种排序算法，它是选择排序的一种。它是通过堆来进行选择数据。需要注意的是排升序要建大堆，排降序建小堆。

2.堆排序的实现

//向下调整
void AdjustDown(int* a, int n, int parent)
{
	int child = parent * 2 + 1;
	while (child < n)
	{
		if (child + 1 < n && a[child] < a[child + 1])
		{
			child++;
		}
		if (a[child] > a[parent])
		{
			Swap(&a[child], &a[parent]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}
//向上调整
void AdjustUp(int* a, int child)
{
	int parent = (child - 1) / 2;
	while (child > 0)
	{
		if (a[parent] < a[child])
		{
			Swap(&a[parent], &a[child]);
			child = parent;
			parent = (child - 1) / 2;
		}
		else
		{
			break;
		}
	}
}
//堆排序
void HeapSort(int* a, int n)
{
	向下调整建堆
	//for (int parent = (n - 1 - 1) / 2; parent >= 0; parent--)
	//{
	//	AdjustDown(a, n, parent);
	//}
	//向下调整建堆
	for (int i = 1; i < n; i++)
	{
		AdjustUp(a, i);
	}
	for (int end = n - 1; end > 0; end--)
	{
		Swap(&a[0], &a[end]);
		AdjustDown(a, end, 0);
	}

}

3.堆排序的特性

堆排序使用堆来选数，效率就高了很多。
时间复杂度：O(N*logN)
空间复杂度：O(1)
稳定性：不稳定

六、冒泡排序

1.冒泡排序的思想

冒泡排序我们其实已经很多次实现过了，他的基本思想就是相邻两个元素两两比较，一趟搞定一个元素。

2. 冒泡排序的实现

//冒泡排序
void BubbleSort(int* a, int n)
{
	for (int i = 0; i < n - 1; i++)
	{
		bool exchange = false;
		for (int j = 0; j < n - i - 1; j++)
		{
			if (a[j] > a[j + 1])
			{
				exchange = true;
				Swap(&a[j], &a[j + 1]);
			}
		}
		if (exchange == false)
		{
			break;
		}
	}
}

七、排序性能测试

测试代码

//测试效率
void TestOP()
{
	srand(time(0));
	const int N = 100000;
	int* a1 = (int*)malloc(sizeof(int) * N);
	int* a2 = (int*)malloc(sizeof(int) * N);
	int* a3 = (int*)malloc(sizeof(int) * N);
	int* a4 = (int*)malloc(sizeof(int) * N);
	//int* a5 = (int*)malloc(sizeof(int) * N);
	//int* a6 = (int*)malloc(sizeof(int) * N);
	int* a7 = (int*)malloc(sizeof(int) * N);

	for (int i = 0; i < N; ++i)
	{
		a1[i] = rand();
		a2[i] = a1[i];
		a3[i] = a1[i];
		a4[i] = a1[i];
		//a5[i] = a1[i];
		//a6[i] = a1[i];
		a7[i] = a1[i];

	}
	int begin1 = clock();
	InsertSort(a1, N);
	int end1 = clock();
	int begin2 = clock();
	ShellSort(a2, N);
	int end2 = clock();
	int begin3 = clock();
	SelectSort(a3, N);
	int end3 = clock();
	int begin4 = clock();
	HeapSort(a4, N);
	int end4 = clock();
	//int begin5 = clock();
	//QuickSort(a5, 0, N - 1);
	//int end5 = clock();
	//int begin6 = clock();
	//MergeSort(a6, N);
	//int end6 = clock();
	int begin7 = clock();
	BubbleSort(a7, N);
	int end7 = clock();
	printf("InsertSort:%d\n", end1 - begin1);
	printf("ShellSort:%d\n", end2 - begin2);
	printf("SelectSort:%d\n", end3 - begin3);
	printf("HeapSort:%d\n", end4 - begin4);
	//printf("QuickSort:%d\n", end5 - begin5);
	//printf("MergeSort:%d\n", end6 - begin6);
	printf("BubbleSort:%d\n", end7 - begin7);
	free(a1);
	free(a2);
	free(a3);
	free(a4);
	//free(a5);
	//free(a6);
	free(a7);

}