排序系列--选择排序和堆排序

1.排序的概念

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

2.选择排序

2.1基本思想：

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

2.2 直接选择排序:

假如最终目标是排成一个升序，在元素集合array[i]到array[n-1]中选择关键码最大(小)的数据元素，若它不是这待排序的集合中的最后一个(第一个)元素，则将它与这集合中的最后一个（第一个）元素交换，在剩余的array[i]到array[n-2]（array[i+1]到array[n-1]）集合中，重复上述步骤，直到集合剩余1个元素，排序结束。

我们可以通过下面动图，直观的感受下：
对代码具体分析：

//交换
void Swap(int* a, int* b)
{
	int temp = 0;
	temp = *a;
	*a = *b;
	*b = temp;
}

//直接选择排序
void SelectSort(int* a, int n)
{
	//一共需要比n趟，但最后一趟只有一个元素可以不用比
	for (int i = 0; i < n - 1; i++)
	{
		//先假设待排序区间第一个元素为最小值
		int mini = i;
		for (int j = i+1; j < n; j++)
		{
			if (a[mini] > a[j])
			{
				mini = j;
			}
		}
		//一趟全部比完，将待排序区间中最小的元素和它的第一个元素交换
		Swap(&a[mini], &a[i]);
	}
}

基于以上的思路我们还可以有进行优化，就是每一趟从待排序区间选出它的最小元素和最大元素，再分别和该待排序区间的第一个元素和最后一个元素交换。如区间下标 [left,right],元素交换完后，left+1, right+1，重复如上操作直到排序结束。这里的优化是减少了它的趟数，但优化得不是很明显，通过大O渐近算法求得的时间复杂度并没有太大变化，还是O（n^2）。自己可以尝试画图作进一步了解。

对代码进行具体分析：

//交换
void Swap(int* a, int* b)
{
	int tmp = 0;
	tmp = *a;
	*a = *b;
	*b = tmp;
}

//选择排序
void SelectSort(int* a, int n)
{
	//用begin和end来控制区间
	int begin = 0, end = n - 1;
	while (begin < end)
	{
		int mini = begin, maxi = begin;
		for (int i = begin; i <= end; i++)
		{
			if (a[i] < a[mini])
			{
				mini = i;
			}
			if (a[i] > a[maxi])
			{
				maxi = i;
			}
		}
		Swap(&a[begin], &a[mini]);
		//判断最大值是否在当前区间的第一个位置
		//如果在，那最小值和第一个元素一换，最大值就被换到原来最小值所在的位置了
		//调整maxi=mini就不会出错了
		if (maxi == begin)
		{
			maxi = mini;
		}
		Swap(&a[end], &a[maxi]);
		begin++;
		end--;
	}
}

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

1. 直接选择排序思想非常好理解，但是效率不是很好，实际中很少使用。
2. 时间复杂度：O(N^2)
   没有被优化的第一种算法第一趟要要比n-1次，第二趟要比n-2次……，依次下去，比较的次数满足等差数列，所以经大O渐近算法求得时间复杂度为O(n^2)。 而被优化后的第二种算法第一趟要比(n-1)*2次，第二趟要比(n-3)*2次……（第二趟待排序的元素比第一趟少了2个），也是一个等差数列，经大O渐近算法求得时间复杂度还是为O(n^2)（虽然有优化，但还无法影响它的时间复杂度级别）。
3. 空间复杂度：O(1) （只创建了常数个变量）
4. 稳定性：不稳定
   如下面这张图中使用第一种未优化的算法进行排序就是不稳定的一种情况，因为5和第一个8进行了交换。
   

2.3堆排序

堆排序(Heapsort)是指利用堆这种数据结构所设计的一种排序算法，它是选择排序的一种。它是通过堆来进行选择数据。需要注意的是排升序要建大堆，排降序建小堆。
这里以排升序为例，先用向下调整算法建立大堆，在前面关于 建堆 的博客中已经详细介绍过了，这里我们以一张动图直观的了解建大堆的过程：

建完大堆我们就可以开始进行堆排序了，因为建立的是大堆，那这个二叉树的第一个结点的值是所有结点中最大的，那将它和最后一个结点交换，交换后存储堆的数组中最后一个元素就是整个数组中最大的（关于堆和二叉树、数组之间的关系在 建堆 中有详细讲解），然后让存储堆的数组的长度减少1，重复上述步骤直到整个排序结束。
下面的动图展示了在大堆基础上进行排序的过程：

//交换
void Swap(int* a, int* b)
{
	int tmp = 0;
	tmp = *a;
	*a = *b;
	*b = tmp;
}

//向下调整
void AdjustDown(int* a, int n, int parent)
{
	//先假设当前待调整结点的左孩子结点存在
	//并且是待调整结点的左右孩子结点（不管右孩子结点存不存在，都这样假设）中值最大的
	int child = parent * 2 + 1;
	child < n 说明左孩子结点确实存在。
	while (child < n)
	{
		//child+1 < n 说明右孩子结点确实存在
		//如果a[child] < a[child+1]也成立，那说明左右孩子结点中值最大的是右孩子结点
		if ((child + 1 < n) && a[child] < a[child + 1])
		{
			child = child + 1;
		}
		//如果a[child]>a[parent],则说明父节点比比左右孩子节点的值都要小，要置换
		if (a[child] > a[parent])
		{
			Swap(&a[child], &a[parent]);
			parent = child;
			child = child * 2 + 1;
		}
		//如果a[child] <= a[parent],那就不需要进行调整
		else
		{
			break;
		}
	}
}

//建大堆
//a接收的是数组的地址，n是数组的长度
void HeapCreat(int* a, int n)
{
	//向下调整是要将该结点去和它的左右子树进行比较，从而移动到适当的位置
	//所以当前结点相当于父节点。
	int parent = (n - 1 - 1) / 2;
	for (int i = parent; i >= 0; i--)
	{
		//i是待调整的当前结点
		AdjustDown(a, n, i);
	}
}

//堆排序
void HeapSort(int* a, int n)
{
	HeapCreat(a, n);
	int i = n;
	while (i > 0)
	{
		Swap(&a[0], &a[i - 1]);
		//i--是将数组的范围从后减1，减掉的就是图中灰色结点
		i--;
		AdjustDown(a, i, 0);
	}
}

堆排序的特性总结：

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

堆排序分为建堆和排序两部分，建堆部分时间复杂度为O(N),而排序部分我们做个大概的估算，首先堆可以近似看成一个满二叉树，假设这个满二叉树共有N个元素，那最后一层就有N/2+1个元素，倒数第二层就有(N/2)/2+1个元素，最后两层就包含了二叉树中大部分的元素。在计算时间复杂度时，就是计算元素交换的次数，我们按用时间最长的情况来算，也就是每次都交换到当前最后一层，我们先只看最后层，高度为logN(以2为底关于N的对数)，最多需要交换的次数大概为logN*(N/2),往上一层高度就减1，这样根据 时间复杂度的算法最终结果为O(N*logN)。

4. 空间复杂度：O(1)
5. 稳定性：不稳定（堆中在交换元素时中间其实是隔了其它元素的，所以会造成不稳定）。