【排序篇】插入排序与选择排序

🌈个人主页：Yui_
🌈Linux专栏：Linux
🌈C语言笔记专栏：C语言笔记
🌈数据结构专栏：数据结构

1. 排序的概念及其应用

1.1 排序的概念

排序：所谓排序，就是使一连串记录，按照其中的某个或者某些关键字的大小，递增或递减的排列起来的操作。
稳定性：假如在待排序的记录序列中，存在多个具有相同关键字的记录中，如果经过排序，这些记录的相对次序保存不变，就是说在原序列中，r[i] = r[j]，且r[i]在r[j]前，然后在后序的排序后，r[i]仍在r[j]前，那么就叫这种排序是稳定的，否则就是不稳定的。
内部排序：数据元素全部放在内存中的排序。
外部排序：数据元素太多不能同时放在内存中，根据排序过程的要求不能在内外存间移动数据的排序。

1.2 排序的应用场景

排序的应用场景非常广泛，任何邻域都存在竞争，只要存在竞争就会有比较，那么就有了高低之分了，比如高校排名：

1.3 常见的排序算法

插入排序

• 直接插入排序
• 希尔排序
  选择排序
• 选择排序
• 堆排序序
  交换排序
• 冒牌排序
• 快速排序
  归并排序
• 归并排序
  

2.常见排序算法的实现

2.1 插入排序

2.1.1 基本思想

直接插入排序是一种简单的插入排序算法，其基本思想为：

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

就像我打扑克牌一样，当我们手中的牌位3 4 5 7的时候，此时摸到了6就会把6插入5和7的中间的到3 4 5 6 7的顺子。

2.1.2 直接插入排序

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

#include <stdio.h>
//维持[0,end]有序
//通过比较把end+1的数据插入到[0,end]中合适的位置，来保存[0,end]的持续有序
void InsertSort(int* arr, int n)
{
	for (int i = 0; i < n - 1; ++i)
	{
		int end = i;
		int tmp = arr[end + 1];//防止end+1位置的数据丢失
		while (end >= 0)
		{
			if (tmp < arr[end])
			{
				arr[end + 1] = arr[end];
				end -= 1;
			}
			else
			{
				break;
			}
		}
		arr[end+1] = tmp;
		//当我们比较到最后，是tmp大于arr[end]所以tmp要在end的后面
		//可不能写成arr[end] = tmp，这样写程序会崩溃的
	}
}
int main()
{
	int arr[10] = { 0,9,8,7,6,5,4,3,2,1 };
	InsertSort(arr, 10);
	for (int i = 0; i < 10; ++i)
	{
		printf("%d ", arr[i]);
	}
	return 0;
}
//打印结果：
/*
0 1 2 3 4 5 6 7 8 9
*/

总结：

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

2.1.3 希尔排序

希尔排序又称缩小增量法。希尔排序法的基本思想：先选定一个数，把待排序文件中所有文件分成个组，所有距离的记录分在同一组内，并对每一组内的记录进行排序。然后，取重复上述分组和排序的工作。当到达gap = 1时，所有记录在统一组内排好序。
本质就是先进行预排序，然后在用直接插入排序。预排序的目的就是为了让数组变得更加有序，而直接插入排序的效率是和数据的有序程度挂钩的，越有序效率越高。

如此一来，代码就好写了，既然最后一次是直接插入排序的逻辑，那么也就说明了主体代码不会有太大的变化，还有因为gap是变化的，我们用一个循环来处理gap。令初始的gap为5，后序的gap = gap/2.循环的执行条件就是gap!=0；
然后因为gap会将数组分组，后续我们就要把i限制在n-gap中了。

#include <stdio.h>
void ShellSort(int* arr, int n)
{
	int gap = 5;
	while (gap)
	{
		for (int i = 0; i < n - gap; i+=1)
		{
			int end = i;
			int tmp = arr[end + gap];
			while (end >= 0)
			{
				if (tmp < arr[end])
				{
					arr[end + gap] = arr[end];
					end -= gap;
				}
				else
				{
					break;
				}
			}
			arr[end + gap] = tmp;
		}
		gap /= 2;
	}
	
}
int main()
{
	int arr[10] = { 0,9,8,7,6,5,4,3,2,1 };
	ShellSort(arr, 10);
	for (int i = 0; i < 10; ++i)
	{
		printf("%d ", arr[i]);
	}
	return 0;
}
//打印结果
/*
0 1 2 3 4 5 6 7 8 9
*/

关于gap的取值
gap当然不是固定的，gap的取值是根据数组大小进行变化的。目前主流的gap取值是n/3+1
后续的变化也是gap = gap/3+1
修改后的代码：

void ShellSort(int* arr, int n)
{
	int gap = n;
	while (gap>1)
	{
		gap = gap / 3 + 1;
		for (int i = 0; i < n - gap; i+=1)
		{
			int end = i;
			int tmp = arr[end + gap];
			while (end >= 0)
			{
				if (tmp < arr[end])
				{
					arr[end + gap] = arr[end];
					end -= gap;
				}
				else
				{
					break;
				}
			}
			arr[end + gap] = tmp;
		}
	}
	
}

总结：

1. 希尔排序是对直接插入排序的优化
2. 当gap>1时都是预排序，目的是为了让数组更接近有序。当gap = 1时，数组已经接近有序了，这样直接插入排序就会很快。整体而言，可以达到优化的效果。
3. 希尔排序的时间复杂度不好计算，因为gap的取值方法多样，导致很难取计算，因此许多书给出的希尔排序的时间复杂度都不固定
4. 稳定性：不稳定。
   下面是一些介绍希尔排序的书籍：
   《数据结构（C语言版）》 — 严蔚敏
   

《数据结构-用面向对象方法与C++描述》 – 殷人昆

2.2 选择排序

2.2.1 基本思想

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

2.2.2 直接选择排序

• 在元素集合array[i]—array[n-1]中选择关键码最大/小的数据元素。
• 如果它不是这组数据中的最后一个元素/第一个元素，那么将它与这组元素中的最后一个/第一个元素交换
• 在剩余的array[i] --array[n-2]（array[i+1]–array[n-1]）集合中，重复上述步骤，直到集合剩余一个元素。
  

#include <stdio.h>
void swap(int* a, int* b)
{
	int tmp = *a;
	*a = *b;
	*b = tmp;
}

void slectsort(int* arr, int n)
{
	for (int i = 0; i < n; ++i)
	{
		int _min = i;
		for (int j = i; j < n; ++j)
		{
			if (arr[j] < arr[_min])
			{
				_min = j;
			}
		}
		swap(&arr[_min], &arr[i]);
	}
}
int main()
{
	int arr[10] = { 0,9,8,7,6,5,4,3,2,1 };
	slectsort(arr, 10);
	for (int i = 0; i < 10; ++i)
	{
		printf("%d ", arr[i]);
	}
	return 0;
}

总结：

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

2.2.3堆排序

堆排序就是利用堆的思想进行排序，总共分为两个步骤：
建堆

• 升序：建大堆
• 降序：建小堆
  利用向下调整建堆
  提问：为什么向下调整可以建堆
  回答：
  向下调整的关键就除了要调节的地方不对，其下方都为正确的堆。
  以下图为例：以10为根的左右子树，都满足小堆（堆）的性质，只有根节点不满足时，因此只需将根节点往下调，整合到合适的位置就可以了。
  

为了我只有由后往前向下调整就可以了，第一次要传的参数就是最后一个节点的父节点。然后依次传入前面是位置就可以了。

#include <stdio.h>

void swap(int* a, int* b)
{
	int tmp = *a;
	*a = *b;
	*b = tmp;
}

//建大堆
void AdjustDown(int* a, int n, int parent)
{
	int child = parent * 2 + 1;
	while (child < n)
	{
		if (child + 1 < n && a[child + 1] > a[child])
		{
			child = child + 1;
		}
		if (a[child] > a[parent])
		{
			swap(&a[child], &a[parent]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}

int main()
{
	int arr[] = { 2,3,5,7,4,6,8,65,100,70,32,50,60 };//初始化一个小堆
	int n = sizeof(arr) / sizeof(arr[0]);
	for (int i = (n - 1 - 1) / 2; i >= 0; --i)
	{
		AdjustDown(arr, n, i);//通过向下调整建立大堆
	}
	for (int i = 0; i < n; ++i)
	{
		printf("%d ", arr[i]);
	}
	return 0;
}
//打印结果：
/*
100 70 60 65 32 50 8 3 7 4 2 5 6
*/

利用堆删除思想来进行排序
建堆和堆删除中都用到了向下调整，因此掌握了向下调整就可以完成堆排序。
提问：为什么升序需要建大堆呢？
回答：堆排序的本质是选择排序，每次都要选择一个最大的数到数组的最后一位，那么问题就变成了如何选择最大的数到数组最后一位，要找出堆中最大数就必须要用到大堆，因为大堆中最大的数就在堆堆顶，通过一次次的选择就可以将数组排序。
下面是画图解释：

#include <stdio.h>

void swap(int* a, int* b)
{
	int tmp = *a;
	*a = *b;
	*b = tmp;
}

//建大堆
void AdjustDown(int* a, int n, int parent)
{
	int child = parent * 2 + 1;
	while (child < n)
	{
		if (child + 1 < n && a[child + 1] > a[child])
		{
			child = child + 1;
		}
		if (a[child] > a[parent])
		{
			swap(&a[child], &a[parent]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}

int main()
{
	int arr[] = { 2,3,5,7,4,6,8,65,100,70,32,50,60 };
	int n = sizeof(arr) / sizeof(arr[0]);
	for (int i = (n - 1 - 1) / 2; i >= 0; --i)
	{
		AdjustDown(arr, n, i);
	}
	//排序
	for (int end = n - 1; end >= 0; --end)
	{
		swap(&arr[0], &arr[end]);
		AdjustDown(arr, end, 0);
	}
	for (int i = 0; i < n; ++i)
	{
		printf("%d ", arr[i]);
	}
	return 0;
}
//打印结果：
/*
2 3 4 5 6 7 8 32 50 60 65 70 100
*/

总结：

1. 堆排序使用堆来选数，效率高
2. 时间复杂度：O(N*logN)
3. 空间复杂度：O(1)
4. 稳定性：不稳定