【数据结构与算法篇】 手撕八大排序算法之选择排序

​👻内容专栏： 《数据结构与算法篇》
🐨本文概括：选择排序包括直接选择排序与堆排序，本篇讲述直接选择排序与堆排序的思想及实现、复杂度及稳定性的分析。
🐼本文作者： 花 蝶
🐸发布时间：2023.8.27

一、直接选择排序

基本思想：

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

若将以上思想拆分成若干步骤，如下：

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

动图演示：

👇小的优化：
🔗：动图中，利用一趟中找出最小的放到序列的起始位置，直到数据排列完，其实，我们不妨想想可以一趟找出最小的数据和待排序中最左边的数据进行交换，找出最大的数据和待排序中最后边的数据进行交换！
首先，确定起始位置和末端位置的下标，我们可以用begin和end表示，在begin和end区间内，遍历一遍，找出最大元素下标maxii和最小元素下标mini，小的元素换到左边，大的元素换到右边，之后我们需要begin++，end--，依次缩小区间，直到走到 begin 大于或等于 end结束

⚠️需要注意一个特殊的情况：
观察下图，maxi在最左边的位置，当找到mini（元素0）之后需要换到左边时，将原本maxi的位置（元素9）给换走了，这就导致最大值与end位置的数据交换时，不是maxi为下标的元素了，所以针对begin等于maxi的情况，我们需要在把最大值换到右边之前进行修正一下。

代码实现：

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

			if (a[i] < a[mini])
			{
				mini = i;
			}
		}
		//小的换到左边
		Swap(&a[begin], &a[mini]);

		//如果maxi与begin重叠，需要进行修正
		if (maxi == begin) maxi = mini;
		//大的换到右边
		Swap(&a[end], &a[maxi]);

		begin++;
		end--;
	}
}

直接选择排序特性：

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

二、堆排序

走到这里，大家需要首先要弄明白什么是堆？
详解具体堆的概念，堆的实现、向上向下调整算法，可以点击这篇文章 【传送门】深入浅出——二叉树

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

基本思想

1.建堆（Heapify）： 首先将待排序的数据构建成一个堆。可以通过从最后一个非叶子节点开始，逐步向前调整节点的位置，（这个称为向下调整算法建堆（倒着调整），具体时间复杂度分析可以看上面标题下给出的文章。）使得每个子树都满足堆的性质。这个过程称为“堆化”。
2.排序： 一旦建立了堆，最大（或最小）元素就位于堆的根节点。将根节点与堆的最后一个元素交换位置，然后将堆的大小减一，使得最大元素“沉”到数组末尾。接着重新堆化剩余的堆，使得次大的元素浮到根节点。
3.重复： 重复上述步骤，直到堆的大小减为1，此时整个数组已经有序。

建堆

例如，以下图中为一个完全二叉数，但还不具有堆的性质，这里我们以排升序为例，所以我们需要将它构建为大堆，需要从最后一个非叶子节点开始倒着往下调整（为什么不直接使用向上调整?具体可看上面给出的文章，因为经过对比计算，向上调整的时间复杂度高于向下调整的时间复杂度），也就是最后一个叶子节点的父节点（(n - 1 - 1) / 2），根据父节点parent的下标位置，求出左孩子节点child，公式：child = parent * 2 + 1，为什么只求出左孩子节点？我们只需要把左孩子与右孩子进行比较，child + 1就能得到右孩子，右孩子存在的情况下，且右孩子大于左孩子，那么就child++，将左孩子节点更新为右孩子节点。然后再去父亲节点进行比较，如果孩子节点大于父亲节点，那么就与父亲交换。需要注意的是，交换之后，一定需要往下继续调整，继续迭代走，即：parent = child ; child = parent * 2 + 1;

排序

建出大堆之后，数组中的首尾数据进行交换，最小的数据(堆顶)放到了最后的位置，除去最后一个数据，对堆进行向下调整，再把堆顶(此时是次小的数据)，与倒数第二个位置的数据交换……以此类推，整个调整完后，数组中的数据依次排列就是一个升序序列。

代码实现

void AdjustDown(int* a, int n, int parent)
{
	int child = parent * 2 + 1;

	while (child < n)
	{
		//假设左孩子小于父亲
		//如果右孩子还小于左孩子，则child ++
		if (child + 1 < n && a[child + 1] > a[child]) child++;

		if (a[child] > a[parent])
		{
			Swap(&a[child], &a[parent]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}
//堆排序 时间复杂度为：O(N*logN)
void HeapSort(int* a, int n)
{
	//建大堆（升序）
	//O(N)
	for (int i = (n - 1 - 1) / 2; i >= 0; i--)
	{
		AdjustDown(a, n, i);
	}

	//堆顶元素和最后一个交换
	//再向下调整
	//O(N*logN)
	int end = n - 1;
	while (end > 0)
	{
		Swap(&a[0], &a[end]);
		AdjustDown(a, end, 0);
		end--;
	}
}

堆排序特性

• 时间复杂度： 堆排序的平均时间复杂度为 O(N*log N)，其中 N 是待排序数组的长度。构建堆的时间复杂度为O(N)，从堆顶调整堆的操作需要O(log n)的时间，而总共需要执行交换操作 n 次，即 O(N + N*logN) 或 O(N*log N) 。
• 空间复杂度： 堆排序的空间复杂度为 O(1)，即排序过程中只需要很少的额外空间来存储临时变量.
• 稳定性： 堆排序是不稳定的排序算法，即在排序过程中，相等元素的相对顺序可能会发生改变。这是因为堆排序涉及到元素交换的操作，可能会导致相同值的元素交换位置。

更多数据结构与算法系列文章👉😉==> 【传送门】