选择排序详解

1. 基本思想

从一个待排序的数组中选择最大或最小的的数据，根据你是要升序还是降序来将这个数据是放在起始还是最后。这也类似于打扑克，只不过情形和插入排序不一样，插入排序是一张一张摸，边摸边排，选择排序是将所有牌摸上来，然后选一个出来。

2. 直接选择排序

2.1 实现

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

void SelectSort(int* a, int n)
{
	int start = 0;
	int end = n - 1;
	while (start < end)
	{
		int min = start;
		int max = start ;
		for (int i = start + 1; i <= end; i++)
		{
			//找最小
			if (a[min] > a[i])
			{
				min = i;
			}
			//找最大
			if (a[max] < a[i])
			{
				max = i;
			}
		}
		//已经找到最大和最小
		Swap(&a[start], &a[min]);
		//这里要注意，上面交换了最小值和start位置的值，如果start的值的是最大的，那么这个值就找不到了，所以要判断调整一下
		if (max == start)
		{
			max = min;
		}
		Swap(&a[end], &a[max]);
		start++;
		end--;
	}
}

2.2 时间和空间复杂度分析

时间复杂度：
选择排序没用最好或者最差的情况，因为每次选出一个数字就必须遍历一遍数组，所以时间复杂度为O（N^2）。

空间复杂度：
没有额外的空间消耗，故空间复杂度为O（1）。

2.3 特性

1. 效率很低，现实生活中很少用。
2. 不稳定。（交换的过程中可能会使位置发生变化）。

3. 堆排序

堆排序(Heapsort)是指利用堆积树（堆）这种数据结构所设计的一种排序算法，它是选择排序的一种。它是通过堆来进行选择数据。
堆是一种特殊的树形数据结构，它满足以下两个特性：

1. 堆是一个完全二叉树：除了最后一层，其他层的节点都是满的，最后一层的节点从左到右依次填入。

2. 堆中的每个节点的值都必须满足堆的性质：对于最大堆（大顶堆）来说，父节点的值大于等于其子节点的值；对于最小堆（小顶堆）来说，父节点的值小于等于其子节点的值。

3.1 实现

在实现排序之前我们需要先建一个堆出来。建堆有两种方式，一个是向上调整法，一个是向下调整法（用的多，时间复杂度小）。
代码展示（建大堆为例）

//向上调整
void AdjustUp(HPDataType* a, int child)
{
	int parent = (child - 1) / 2;
	while (child > 0)
	{
		if (a[child] > a[parent])
		{
			Swap(&a[child], &a[parent]);
			child = parent;
			parent = (parent - 1) / 2;
		}
		else
		{
			break;
		}
	}
}
 //向下调整
void AdjustDwon(int* a, int n, int root)
{
	int child = 2 * root + 1;
	while (child < n)
	{
		if (child + 1 < n && a[child + 1] > a[child])
		{
			child++;
		}
		if (a[child] > a[root])
		{
			Swap(&a[child], &a[root]);
			root = child;
			child = 2 * root + 1;
		}
		else
		{
			break;
		}
	}
}

ok啊，这边也是先会建堆了，现在思考一个问题：升序是建大堆还是小堆？答案是建大堆。可能很多小伙伴会想着建小堆可以直接拿到最小的数了，不是很好吗，确实是这样，但是往后想，你取走第一个数之后这个堆的结构被破坏了，要重新建一个堆再取最小数，但是建堆的时间复杂度很高，所以这样还不如上面的直接选择排序，所以我们选择建大堆，取得最大的数和最后一个位置交换，这样没有破坏堆的整体结构，只需向下调整之后，就可以重新选到最大值，向下调整算法的时间复杂度很低，所以我们选择建大堆。
代码展示

//升序
void HeapSort(int* a, int n)
{
	//先向下调整建大堆 O(N)
	for (int i = (n - 1 - 1) / 2; i >= 0; i--)
	{
		AdjustDwon(a, n,i);
	}
	int end = n - 1;
	//向下调整一次性为O(logN),共调整了N-1次，故为O(N * logN)
	while (end > 0)
	{
		Swap(&a[0], &a[end]);
		AdjustDwon(a,end, 0);
		end--;
	}
}

3.2 时间和空间复杂度分析

时间复杂度分析：
向上建堆的时间复杂度为O（N * logN）

向下建堆的时间复杂度为O（N）

堆排序时间复杂度：
建好堆之后，我们每排好一个数之后，就需要向下调整，选出第二个数，向下调整的时间复杂度为高度O（logN），所以总时间复杂度为O（N * logN）

3.3 特性

1. 堆排序效率很高。
2. 不稳定（交换的时候会破坏稳定性）。