08选择排序算法---直接选择排序和堆排序

---

---

一、直接选择排序

它的实现方式是遍历整个数组然后找到最小和最大的数将它们放到数组的开头和结尾，然后缩小范围重复这个过程。

这个动图是只找最小的数：

代码实现：

void SelectSort(int* a, int n)
{
	int begin = 0, end = n - 1;//起始位置下标，最后一个元素下标
	while (begin < end)
	{
		int min = begin, max = begin;//min保存最小元素的下标,max保存最大元素下标
		for (int i = begin; i <= end; i++)
		{
			if (a[i] < a[min])//保存最小元素下标
			{
				min = i;
			}
			if (a[i] > a[max])//保存最大元素下标
			{
				max = i;
			}
		}
		Swap(&a[begin], &a[min]);//交换begin位置的元素和最小的元素
		//如果begin和max重叠，需要修正max位置
		if (begin == max)
		{
			max = min;
		}
		Swap(&a[max], &a[end]);//交换end位置的元素和最大的元素
		begin++;
		end--;
	}
}

注意要如果max和begin重合要修正max位置，否则会把最小的数放到最后：

1.2.时间和空间复杂度分析

直接选择排序看上去非常直观，但是性能非常差，因为无论是否有序都要两层循环遍历一遍选择最大最小的数，然后交换
时间复杂度：O（N²）
空间复杂度：O（1）

---

二、堆排序

对排序的前提是整个数组是一个大堆或者小堆，这个过程称为建堆。

2.1.堆和向下调整算法

要理解堆排序，首先需要了解堆是什么。

数据结构中的栈和堆与我们内存中的栈区和堆区是没有任何关系。

在数据结构中，堆的逻辑结构是一颗完全二叉树，堆的物理结构是一个数组。
堆的两个特性：

• 结构性：用数组表示的完全二叉树
• 任一树的父节点都大于等于子节点：大堆
• 任一树的父节点都小于等于子节点：小堆

父子节点的下标关系：

leftchild=parent*2+1;//左孩子节点下标为父节点下标*2+1
rightchild=parent*2+2;//右孩子节点下标为父节点下标*2+2

比如下面的父节点D的左孩子节点H下标3*2+1，右孩子节点I下标3*2+2

了解完堆，还需要了解一个向下调整算法，因为只有用这个算法，才能将数组调整成为大堆或者小堆，但是向下调整算法有一个前提：
若想将其调整为小堆，那么根结点的左右子树必须都为小堆。
若想将其调整为大堆，那么根结点的左右子树必须都为大堆。

//向下调整算法
//建大堆
void AdjustDwon(int* a, int n, int root)
{
	int parent = root;//父亲节点是传入的数组坐标root
	int child = parent * 2 + 1;//默认指向左孩子
	while (child<n)
	{
		//选出左右孩子中大的那一个
		if (child+1<n&&a[child + 1] > a[child])//如果右孩子比左孩子大，指向右孩子
		//child+1<n防止出现没有右孩子的情况
		{
			child++;//指向右孩子
		}
		if (a[child] > a[parent])//如果孩子比父亲大，交换
		{
			Swap(&a[child], &a[parent]);//交换孩子节点和父节点
			//继续往下调整，直到叶子节点
			parent = child;//将父亲指向孩子
			child = parent * 2 + 1;//孩子指向孩子的左孩子
		}
		else//如果孩子比父亲小，说明堆已经完成
		{
			break;
		}
	}
}

2.2.使用向下调整算法建堆

向下调整算法的前提是左右子树都是小堆或者大堆，堆排序的前提是整个数组是大堆或者小堆。但是数组一开始的根节点左右子树不一定是大堆或者小堆，就不能直接使用向下调整算法了。这种情况如何建堆呢？

我们只需要从倒数从最后一颗非叶子节点的子树开始调即可：

//把数组建成堆   建堆的时间复杂度是O（N）
	for (int i = (n - 1 - 1) / 2; i >= 0; i--)
	{
		AdjustDwon(a, n, i);
	}

经过这样调整以后，我们就可以得到一个大堆，接下来只需要排序即可：

2.3.堆排序

得到大堆以后，根节点的元素是整个数组最大的元素，这个时候只需要把根节点（堆顶）的元素和最后一个节点（堆底）的元素交换，然后忽略最后一个节点，把前n-1个节点的数向下调整，然后再选出次大的数，再和倒数第二个节点交换，一直不断重复即可：

//堆排序
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;//记录堆的最后一个数据的下标
	while (end > 0)
	{
		Swap(&a[0], &a[end]);//将堆顶的数据和堆的最后一个数据交换
		AdjustDwon(a, end,0);//对根进行一次向下调整
		end--;//堆的最后一个数据的下标减一
	}
}

2.4.时间空间复杂度分析

建堆的时间复杂度：

建堆的时间复杂度：
T(n)=1×(h−1)+2×(h−2)+4x(h-3)…+2^h−3×2+2^h−2×1

两边同时乘以2然后相减，最终结果为：
T(n)=2^h−h−1
由二叉树的性质，有 N=2^h−1和 h = log ⁡ ₂ ( N + 1 )
于是T ( n ) = N - log_⁡2( N + 1 )
用大O的渐进表示法：
T ( n ) = O ( N )
也就是最终需要交换N次

向下调整算法的时间复杂度：
使用堆的向下调整算法，最坏的情况下（即一直需要交换结点），需要循环的次数为：h - 1次（h为树的高度）。而h = log₂(N+1)（N为树的总结点数）。所以堆的向下调整算法的时间复杂度为：O(logN)

堆排序的时间复杂度：
堆排序有n-1个人数需要交换并且进行向下调整算法，并且再算上建堆的时间，总的时间为N*log₂(N+1)+N。
所以总的时间复杂度为：
O（N） + O（NlogN） = O（NlogN）
空间复杂度O（1）

---