【排序算法(二)】选择排序（直接选择排序&&堆排序）

​

​📝个人主页：@Sherry的成长之路
🏠学习社区：Sherry的成长之路（个人社区）
📖专栏链接：数据结构
🎯长路漫漫浩浩，万事皆有期待

上一篇博客：【排序算法】排序算法介绍及插入排序 ( 直接插入排序 && 希尔排序 )

1、直接选择排序

1.1 排序思路

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

选择排序的步骤：

在元素集合 array[i]−−array[n−1] 中选择最大(小)的数据元素，若它不是这组元素中的最后一个(第一个)元素，则将它与这组元素中的最后一个（第一个）元素交换

在剩余的 array[i]−−array[n−2]（array[i+1]−−array[n−1]）集合中，重复上述步骤，直到集合剩余 1个元素

下面用动图展示过程：

1.2 代码实现

假设我们排升序，那么每次就要选最小数的下标mini ，遍历数组，找出 mini ，然后交换，让起始位置begin++ ，直到begin=n 停止，此刻数组就有序了。

void Swap(int* a, int* b)
{
	int tmp = *a;
	*a = *b;
	*b = tmp;
}
void SelectSort(int* a, int n)
{
	// 选 1 个数
	int begin = 0;

	while (begin < n)
	{
		int mini = begin;

		for (int i = begin + 1; i < n; i++)
		{
			if (a[i] < a[mini])
			{
				mini = i;
			}
		}

		Swap(&a[begin], &a[mini]);
		begin++;
	}
}

这是单次选 1个数的情况，实际上我们还可以一次选两个数mini 和maxi 对应最小和最大值

这里代码需要做出一些改变，增加一个终止位置 end 。循环找 mini 和maxi ，每次找到之后交换begin 和 mini 对应的值和 end 和 maxi 对应的值，将begin++,end−− ，直到 begin≥end 。

注意
假设序列已经找到了mini 和maxi ：

begin 和maxi 的位置重合了，那么begin 和mini 在交换的时候，就把最小值换到了 begin(maxi) 处，最大值被换走了 。那么接下来交换 end 和maxi 的时候，就把 最小值 换到了end 处。

这就导致了排序错误，在 begin==maxi 时，在交换过begin 和mini 的值后，原 mini 的值为当前的最大值，那么就把 maxi=mini ，让最大值下一次能交换到正确的位置。

void Swap(int* a, int* b)
{
	int tmp = *a;
	*a = *b;
	*b = tmp;
}
void SelectSort(int* a, int n)
{
	int begin = 0, end = n - 1;

	while (begin < end)
	{
		int mini = begin, maxi = begin;

		for (int i = begin + 1; i <= end; i++)
		{
			if (a[i] < a[mini])
			{
				mini = i;
			}

			if (a[i] > a[maxi])
			{
				maxi = i;
			}
		}

		Swap(&a[begin], &a[mini]);
		// 特殊处理
		//当a数组里第1个元素是最大值时，此时经过上面的Swap，最大值的位置已经更改了，所以需要修正最大值的位置，让下一个Swap正确交换
        if (begin == maxi)
		{
			maxi = mini;
		}
		Swap(&a[end], &a[maxi]);
		begin++;
		end--;
	}
}

1.3 特性及复杂度

选择排序无论是选单边，还是两边一起选，时间复杂度都是 O(N^2)。
因为总是要每次遍历选出 最小或最大下标，然后进行数据交换。

所以选择排序的效率是不太行的，一般不常用，但是它的思路很简单。

空间复杂度是O(1) ，因为没有开辟额外空间 。

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

2、堆排序

2.1 排序思路

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

2.2 代码实现

1.首先通过向下调整或向上调整的方式建堆，推荐向下调整，因为效率更高，具体原因及复杂度分析看这篇博客：【树与二叉树】堆的时间复杂度详解以及堆的应用—堆排序、TOP - K问题
向上调整建堆：模拟插入的过程
向下调整建堆：模拟删除的过程，这里从倒数的第一个非叶子节点开始调整

2.堆创建后，如何进行排序 (升序、降序)
升序建大堆；降序建小堆。不是说升序建小堆；降序建大堆不行，而是因为不好：
如果排升序建小堆：
  1、选出最小的数，最小的数就放在第一个位置
  2、接着就要选次小的数，再选次小的数 … … 不断的选下去，如何选 ？
只能对剩下的 sz-1、sz-2、sz-3 … 个数继续建堆。可想这样的代价是很高的 —— 建堆的时间复杂度是 O(N)，整个时间复杂度就是 O(N^2)，堆的价值没有体现，不如直接循环遍历

如果排升序建大堆：
  1、选出最大的数，与最后一个数交换位置
  2、怎么选出次大、次次大 ？
堆的结构没有被破坏，且最后一个数不看做堆，左右子树依旧是大堆，向下调整即可
最多调整 log₂N 次，整体的时间复杂度是 O(N*log₂N）

综上：升序建大堆、降序建小堆

//实现父子交换的函数
void Swap(int* px, int* py)
{
	int temp = *px;
	*px = *py;
	*py = temp;
}
//实现调整
void AdjustDown(int* arr, int sz, int parent)
{
	//确定左孩子的下标
	int child = parent * 2 + 1;
	//孩子的下标超出数组的范围就停止
	while (child < sz)
	{
		//确定左右孩子中较小/大的那个
			//左孩子大于右孩子，所以让child记录较小孩子的下标 || (arr[child]<arr[child+1]记录较大孩子的下标)
		if (arr[child] > arr[child + 1] && child + 1 < sz)
		{
			child++; //(当只有一个左孩子时，会越界，且后面使用时会发生非法访问)
		}
		//判断父亲和小孩子
			//小孩子小于父亲，则交换，且继续调整 || (arr[child]>arr[parent]大孩子大于父亲，则交换，且继续调整)
		if (arr[child] < arr[parent])
		{
			Swap(&arr[child], &arr[parent]);
			//迭代
			parent = child;
			//重新确定左孩子的下标(当最后的叶子节点是parent时，这时去确定child会以读的方式越界，但可以不关心)
			child = parent * 2 + 1;
		}
		//小孩子大于父亲，则停止调整
		else
		{
			break;
		}
	}
}
//堆排序 -> 效率更高
void HeapSort(int* arr, int sz)
{
	//建堆
	int i = 0;
	//从最后一棵树开始调整，也就是最后一个节点的父亲
	for (i = (sz - 1 - 1) / 2; i >= 0; i--)
	{
		AdjustDown(arr, sz, i);
	}
}

2.3 特性及复杂度

堆排序的时空复杂度在之前的文章已经详细分析过
详情见这篇博客：【树与二叉树】堆的时间复杂度详解以及堆的应用—堆排序、TOP - K问题

时间复杂度：O(N*logN)，空间复杂度 O(1) 。

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

3.总结：

今天我们认识并具体学习了选择排序算法中的直接选择排序和堆排序。下一篇博客，我们将继续学习选择排序中的冒泡排序和快速排序。希望我的文章和讲解能对大家的学习提供一些帮助。

当然，本文仍有许多不足之处，欢迎各位小伙伴们随时私信交流、批评指正！我们下期见~