【初阶数据结构】10.排序（1）

---

1.排序概念及运用

1.1 概念

排序：所谓排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。

---

1.2 运用

购物筛选排序

---

1.3 常见排序算法

---

2. 实现常见排序算法

2.1 插入排序

基本思想

直接插入排序是一种简单的插入排序法，其基本思想是：把待排序的记录按其关键码值的大小逐个插入到一个已经排好序的有序序列中，直到所有的记录插入完为止，得到一个新的有序序列 。

2.1.1 直接插入排序

当插入第 i(i>=1) 个元素时，前面的 array[0],array[1],…,array[i-1] 已经排好序，此时用 array[i] 的排序码与 array[i-1],array[i-2],… 的排序码顺序进行比较，找到插入位置即将 array[i] 插入，原来位置上的元素顺序后移

代码实现：

Sort.h

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include<stdlib.h>
#include<time.h>

//打印
void PrintArr(int* arr, int n);

//直接插入排序
void InsertSort(int* arr, int n);

Sort.c

#define _CRT_SECURE_NO_WARNINGS 1
#include"Sort.h"

//打印
void PrintArr(int* arr, int n)
{
	for (int i = 0; i < n; i++)
	{
		printf("%d ", arr[i]);
	}
	printf("\n");
}

//直接插入排序
//最差情况：O(n^2)
//最好的情况:O(n）
void InsertSort(int* arr, int n)
{
	//n-2
	for (int i = 0; i < n - 1; i++)
	{
		int end = i;
		int tmp = arr[end + 1];

		while (end >= 0)
		{
			if (arr[end] > tmp)
			{
				arr[end + 1] = arr[end];
				end--;
			}
			else {
				break;
			}
		}
		//end == -1的时候跳出循环，arr[end + 1] = arr[0]
		arr[end + 1] = tmp;
	}
}

test.c

int main()
{
	int a[] = { 5, 3, 9, 6, 2, 4, 7, 1, 8 };
	int n = sizeof(a) / sizeof(int);
	printf("排序前：");
	PrintArr(a, n);

	InsertSort(a,n);

	printf("排序后：");
	PrintArr(a, n);

	return 0;
}

---

直接插入排序的特性总结

1. 元素集合越接近有序，直接插入排序算法的时间效率越高
2. 时间复杂度：O(N²)
3. 空间复杂度：O(1)

---

2.1.2 希尔排序

希尔排序法又称缩小增量法。希尔排序法的基本思想是：先选定一个整数（通常是gap = n/3+1），把待排序文件所有记录分成各组，所有的距离相等的记录分在同一组内，并对每一组内的记录进行排序，然后gap=gap/3+1得到下一个整数，再将数组分成各组，进行插入排序，当gap=1时，就相当于直接插入排序。它是在直接插入排序算法的基础上进行改进而来的，综合来说它的效率肯定是要高于直接插入排序算法的。

第一趟排序：n=10，gap=n/2=5

分成五组，每组都用直接插入排序。

end一开始放在9的位置上，tmp放在4的位置上

第二趟排序：gap=5，gap=gap/3+1=2

分成两组，每组都用直接插入排序。

end一开始放在4的位置上，tmp放在2的位置上

第三趟排序：gap=2,gap=gap/3+1=1

直接插入排序

希尔排序的特性总结

1. 希尔排序是对直接插入排序的优化。

2. 当 gap > 1 时都是预排序，目的是让数组更接近于有序。

   当 gap == 1 时，数组已经接近有序的了，直接插入排序。

代码实现：

Sort.h

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include<stdlib.h>
#include<time.h>

//打印
void PrintArr(int* arr, int n);

//希尔排序
void ShellSort(int* arr, int n);

Sort.c

#define _CRT_SECURE_NO_WARNINGS 1
#include"Sort.h"

//打印
void PrintArr(int* arr, int n)
{
	for (int i = 0; i < n; i++)
	{
		printf("%d ", arr[i]);
	}
	printf("\n");
}

//希尔排序时间复杂度：O（n^1.3)
void ShellSort(int* arr, int n)
{
	int gap = n;//6

	while (gap > 1)
	{
		gap = gap / 3 + 1;//保证最后一次gap一定为1
		for (int i = 0; i < n - gap; i++)// i < n - gap是为了防止下面的tmp访问数组元素越界
		{
			int end = i;//n - gap - 1
			int tmp = arr[end + gap];//n - 1
			while (end >= 0)
			{
				if (arr[end] > tmp)
				{
					arr[end + gap] = arr[end];
					end -= gap;
				}
				else {
					break;
				}
			}
			//也就是arr[end] = tmp;
			arr[end + gap] = tmp;
		}
	}
}

test.c

int main()
{
	int a[] = { 5, 3, 9, 6, 2, 4, 7, 1, 8 };
	int n = sizeof(a) / sizeof(int);
	printf("排序前：");
	PrintArr(a, n);

	ShellSort(a,n);

	printf("排序后：");
	PrintArr(a, n);

	return 0;
}

---

2.1.2.1 希尔排序的时间复杂度计算

希尔排序的时间复杂度估算：

外层循环：

外层循环的时间复杂度可以直接给出为：O(log₂n) 或者O(log₃n) ，即O(log n)

内层循环：

通过以上的分析，可以画出这样的曲线图：

因此，希尔排序在最初和最后的排序的次数都为n，即前一阶段排序次数是逐渐上升的状态，当到达某一顶点时，排序次数逐渐下降至n，而该顶点的计算暂时无法给出具体的计算过程。

希尔排序时间复杂度不好计算，因为 gap 的取值很多，导致很难去计算，因此很多书中给出的希尔排序的时间复杂度都不固定。《数据结构(C语言版)》— 严蔚敏书中给出的时间复杂度为：

---

2.2 选择排序

选择排序的基本思想：

每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完 。

2.2.1 直接选择排序

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

代码实现：

Sort.h

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include<stdlib.h>
#include<time.h>

//打印
void PrintArr(int* arr, int n);

//直接选择排序
void SelectSort(int* arr, int n);

Sort.c

#define _CRT_SECURE_NO_WARNINGS 1
#include"Sort.h"

//交换
void Swap(int* x, int* y)
{
	int tmp = *x;
	*x = *y;
	*y = tmp;
}

//打印
void PrintArr(int* arr, int n)
{
	for (int i = 0; i < n; i++)
	{
		printf("%d ", arr[i]);
	}
	printf("\n");
}

//直接选择排序
//时间复杂度为O(n^2)

//优化前的
//将后面元素中最小的和第i个元素相比较，比第i个元素小的就交换。
/*
void SelectSort(int* arr, int n) {
	for (int i = 0; i < n; i++)
	{
		int mini = i;
		//找最小的
		for (size_t j = i + 1; j < n; j++) {
			if (arr[i] < arr[mini])
			{
				mini = i;
			}
		}
		//找到了最小值，i和mini位置数据进行交换
		Swap(&arr[i], &arr[mini]);
	}
}
*/

//优化后的
//找到n个元素中最大和最小的，分别给第一个和最后一个元素。
//然后在剩下来的元素里面找最大和最小的，分别给第一个和最后一个元素。
void SelectSort(int* arr, int n)
{
	int begin = 0;
	int end = n - 1;

	while (begin < end)
	{
		int mini = begin, maxi = begin;
		for (int i = begin + 1; i <= end; i++)
		{
			if (arr[i] > arr[maxi])
			{
				maxi = i;
			}
			if (arr[i] < arr[mini])
			{
				mini = i;
			}
		}
		//mini begin
		//maxi end
		//避免maxi begini都在同一个位置，begin和mini交换之后，maxi数据变成了最小的数据
		if (maxi == begin)
		{
			maxi = mini;
		}
		Swap(&arr[mini], &arr[begin]);//最小的放到begin
		Swap(&arr[maxi], &arr[end]);//最大的放到end

		++begin;
		--end;
	}

}

test.c

int main()
{
	int a[] = { 5, 3, 9, 6, 2, 4, 7, 1, 8 };
	int n = sizeof(a) / sizeof(int);
	printf("排序前：");
	PrintArr(a, n);

	SelectSort(a,n);

	printf("排序后：");
	PrintArr(a, n);

	return 0;
}

直接选择排序的特性总结：

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

---

2.2.2 堆排序

堆排序(Heapsort)是指利用堆积树（堆）这种数据结构所设计的一种排序算法，它是选择排序的一种。它是通过堆来进行选择数据。需要注意的是排升序要建大堆，排降序建小堆。在二叉树章节我们已经实现过堆排序，这里不再赘述。