【C语言简单实现数据结构】排序之插入排序和选择排序

【C语言简单实现数据结构】排序之插入排序和选择排序

心有所向，日复一日，必有精进

---

目录

【C语言简单实现数据结构】排序之插入排序和选择排序

前言

一、插入排序

基本思想：

直接插入排序

 算法步骤

代码实现：

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

 希尔排序 

基本思想：

算法步骤

 代码实现：  

  希尔排序的特性总结：

二、选择排序

 基本思想

直接选择排序

基本思想

算法步骤 

代码实现 

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

堆排序

堆排序的特性总结：

---

前言

常见的排序算法：

  怎么感觉有点多呀！ 

 但是，没有关系，从本次文章开始，将梳理这些排序。here we go！

在开始前捏，了解排序的一些知识：

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

---

一、插入排序

基本思想：

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

直接插入排序

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

 图片来源与网络，侵删

 算法步骤

1. 从第一个元素开始，我们看做一个有序区间，后面的区间为待排区间
2. 每次后面插入一个元素，找到位序后插入，保持区间有序，直至插完
3. 但操作实际上均在其完整数组内进行，逻辑上类似插入，因此叫直接插入排序

代码实现：

// 插入排序
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 (a[end] > tmp){
				a[end+1] = a[end];
				end--;
			}
			else{ break; }	
		}
		a[end + 1] = tmp;
	}
}

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

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

 希尔排序 

希尔排序法又称缩小增量法。

基本思想：

先选定一个整数，把待排序文件中所有记录分成个组，所有距离为的记录分在同一组内，并对每一组内的记录进行排序。然后，取，重复上述分组和排序的工作。当到达=1时，所有记录在统一组内排好序。

算法步骤

希尔排序本质上也是一种插入排序，预排序+直接插入排序；采用分组插入的方法；

1. 先将整个待排序序列分割成几组，从而减少直接插入排序的数据量；
2. 对每组分别进行直接插入排序，然后增加每组数据量，从新分组；
3. 经过几次分组排序后，整个序列中基本有序时，在对整个序列进行一次直接插入排序；

 代码实现：  

有两种思想方式：

void ShellSort(int* a, int n)
{
int gap = 3;
for (int j = 0; j < gap; ++j)
{
	for (int i = j; i < n - gap; i += gap)
	{
		// [0,end] 插入 end+gap [0, end+gap]有序  -- 间隔为gap的数据
		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;
	}
}	

// gap > 1  预排序
// gap == 1 直接插入排序

在每一趟排序中，先对每一个分组排序后在进行下一分组； 

// O(N^1.3)
void ShellSort(int* a, int n)
{
	int gap = n;
	while (gap > 1)
	{
		//gap = gap / 2;
		gap = gap / 3 + 1;

		// [0,end] 插入 end+gap [0, end+gap]有序  -- 间隔为gap的数据
		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;
		}
	}
}

 在每一趟排序中，每一组同时进行排序； 

  希尔排序的特性总结：

       1. 希尔排序是对直接插入排序的优化。
       2. 当gap > 1时都是预排序，目的是让数组更接近于有序。当gap == 1时，数组已经接近有序              的了，这样就会很快。这样整体而言，可以达到优化的效果。我们实现后可以进行性能测             试的对比。
       3. 希尔排序的时间复杂度不好计算，因为gap的取值方法很多，导致很难去计算，因此在好些         树中给出的希尔排序的时间复杂度都不固定，大致结论是 O(N^1.3)

       4. 稳定性：不稳定
 

二、选择排序

 基本思想

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

直接选择排序

基本思想

     每一次在序列中寻找最值（最大或最小），放在待排序列的开始位置，直到排序完成。

算法步骤 

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

  图片来源与网络，侵删

代码实现 

这里代码是一种优化形式，每次选出最小和最大，一次性选取两个值，虽然时间复杂度依旧是

O（)；

错误代码

void SelectSort(int* a, int n){
	int begin = 0; int end = n - 1;
	while(begin<end){
		int max = end;
		int min = begin;
		for (int j = begin; j <= end;j++){
			if (a[j] < a[min])min = j;
			if (a[j] >a[max])max = j;
		}
		Swap(&a[min], &a[begin]);
		Swap(&a[max], &a[end]);
		begin++;
		end--;
	}
}

上述代码是错误的 ，可以思考为什么是错误的，这里记录的是对应下标，

所以当最小值交换的时候会影响最大值，假如最小值所交换位置与最大值相撞，

那么最大值将会被换走；

 在通过调试体会错误：

通过上面的调试我们就发现这个验证的问题。下面给出解决代码：

// 选择排序
//int a[] = { 100, 15, 1, 19, 25, 8, 34, 65, 4, 27, 7 };
void SelectSort(int* a, int n){
	int begin = 0; int end = n - 1;
	while(begin<end){
		int max = end;
		int min = begin;
		for (int j = begin; j <= end;j++){
			if (a[j] < a[min])min = j;
			if (a[j] >a[max])max = j;
		}
		Swap(&a[min], &a[begin]);
		if (max == begin){
			max = min;
		}
		Swap(&a[max], &a[end]);
		begin++;
		end--;
	}
}

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

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

堆排序

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

代码实现 

//向下调整
void AdjustDown(HPDataType* a, int n, int parent)
{
	//最大的默认为左孩子
	int minchild = 2 * parent + 1;
	while (minchild <n)
	{
		//找出大的那个孩子
		if (minchild + 1<n&&a[minchild + 1] > a[minchild])
		{
			minchild++;
		}
		//大堆
		if (a[minchild] > a[parent])
		{
			Swap(&a[minchild], &a[parent]);
			parent = minchild;
			minchild = 2 * parent + 1;
		}
		else
		{
			break;
		}
	}
}
 
void HeapSort(int* a, int n)
{
	//建堆——向下调整建堆(从最后一个节点的父亲开始,开始向下调整，直到根)
	for (int i = (n - 1 - 1) / 2; i >= 0; i--)
	{
		AdjustDown(a, n, i);
	}
	//选数
	int i = 1;
	while (i < n)
	{
		Swap(&a[0], &a[n - i]);
		AdjustDown(a, n - i, 0);
		i++;
	}
 
}

对于具体堆的细节详解二叉树文章中查看；

堆排序的特性总结：

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

---

总结

本文中的排序相对来说实现起来比较简单，我们也有了初步认识，下篇文章将梳理交换排序和归并排序，再会。

如遇错误，欢迎指正！