选择排序和堆排序

目录

1.基本思想：

2.直接选择排序:

3.堆排序

1.基本思想：

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

2.直接选择排序:

        在元素集合array[i]--array[n-1] 中选择关键码最大 ( 小 ) 的数据元素

        若它不是这组元素中的最后一个( 第一个 ) 元素，则将它与这组元素中的最后一个（第一个）元素交换

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

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

        1. 直接选择排序思考非常好理解，但是效率不是很好。实际中很少使用

        2. 时间复杂度： O(N^2)

        3. 空间复杂度： O(1)

        4. 稳定性：不稳定

注意：

以下讲解全是建立在升序基础上。

直接选择排序的 核心思想是遍历数组将最小和最大的值分别储存到mini和maxi中，再将mini与begin交换，maxi与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]);

		Swap(&a[end], &a[maxi]);

接着就是一步一步缩小需要便利的数组长度，知道begin不在小于end，排序就完成了。

    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]);

		Swap(&a[end], &a[maxi]);

		++begin;
		--end;
	}

注意：

在直接插入排序中有一个 大坑，就是当Swap完了begin和mini处的数据后， 若maxi数据位于begin处，则会导致下一步Swap  end与maxi时，将begin处的最小数据放入到end中了，造成了不可逆的影响（因为end会减减），使得最小数据放到最后出永不能改变。

所以，我们 需要在Swapbegin和mini后做出判断：
 

	    Swap(&a[begin], &a[mini]);
		if (maxi == begin)
		{
			maxi = mini;
		}

		Swap(&a[end], &a[maxi]);

这样就能避免上述大坑。

完整直接插入排序：
 

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]);
		if (maxi == begin)
		{
			maxi = mini;
		}

		Swap(&a[end], &a[maxi]);

		++begin;
		--end;
	}
}

3.堆排序

堆排序的核心思想就在于建堆时的讲究：

        升序建大堆；

        降序排小堆。

因为我们要利用交换思想方便讲最大的数据一个个的调整到最后位置（建完之后的堆不是有序的），每次Swap最大的值和end位置的值之后，通过向下调整，就可以将次大的值调整到根部，接着就进入了Swap和向下调整的循环。

完整堆排序：

// 升序
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;
	}
}

AdjustDown：

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

	while (child < size)
	{
		// 假设左孩子小，如果解设错了，更新一下
		if (child + 1 < size && a[child + 1] > a[child])
		{
			++child;
		}

		if (a[child] > a[parent])
		{
			Swap(&a[child], &a[parent]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}

详细堆排序见：

链接