排序——选择排序

基本思想

每一趟（第i趟，i=1,2,...，n-2）在后面n-i个待排序的数据元素集合中选出关键码最小的数据，作为有序元素序列的第i个元素。待到第n-2趟做完，待排序元素中只剩下1个元素，排序结束。

直接选择排序

操作步骤：

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

2）若它不是这组元素中的第一个元素，则将它与这组元素中的第一个元素交换

3）在剩余的array[i+1]——array[n-1]集合中，重复1）、2），直到集合剩下1个元素

程序代码：

//一次只选出关键码最小的直接排序
void DirectSecletSort1(int* array, int size)
{
	for (size_t i = 0; i < size -1; i++)
	{
		size_t minPox = i;//关键码
		for (size_t j = i + 1; j < size; j++)
		{
			//选出关键码最小的
			if (array[j] < array[minPox])
				minPox = j;
		}
		//交换数据
		if (minPox != i)
			swap(array[i], array[minPox]);
	}
}

//一次同时选择关键码最大的和最小的直接排序
void DirectSecletSort2(int *array, int size)
{
	int begin = 0;
	int end = size - 1;
	while (begin < end)
	{
		size_t i = begin;
		size_t maxPox = begin;
		size_t minPox = begin;
		//同时选出关键码最小的和最大的
		while (i <= end)
		{
			if (array[i] <= array[minPox])
				minPox = i;
			if (array[i] >= array[maxPox])
				maxPox = i;
			i++;
		}
		//交换数据
		if (minPox != begin)
			swap(array[begin], array[minPox]);
		if (maxPox != end)
			swap(array[end], array[maxPox]);
		if (begin == end)
			swap(array[minPox], array[maxPox]);
		begin++;
		end--;
	}
}

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

稳定性：不稳定锦

 

锦标赛排序

基本思想：首先取得n个元素的关键码，进行两两比较，得到n/2（向上取整）个比较的优胜者，作为第一步比较的结果保留下来。然后对这n/2（向上取整）个元素再进行关键码的两两比较，...，如此重复，直到选出一个关键码最小的元素为止。

一旦选择出这个元素，就需要在下次选择最小关键码之前把它的值改为最大值，使它再也不能战胜其他对手，此时需要重构胜者树得到新的优胜者，作为该排序下的下一个元素，重构的时间代价为lg(N)。

堆排序

1）创建堆：升序——大堆  降序——小堆

2）堆排序：用堆顶元素和最后一个元素交换，调整堆（最后一个元素不用调整）

a、把堆顶array[0]元素和当前最后一个元素（第一个非叶子结点为第一次的最后一个元素）交换

b、最大堆元素个数减1

c、由于第1步后根节点不在满足最堆的定义，向下调整根节点

d、循环a、b、c，知道数组为空

程序代码：

void Adjust(int *array, int size, size_t parent)//调整堆
{
	size_t child = parent * 2 + 1;
	while (child < size)
	{
		//右孩子存在且右孩子大于左孩子
		if ((child + 1 < size) && (array[child + 1] > array[child]))
		{
			child += 1;
		}
		if (array[parent] < array[child])
		{
			swap(array[parent], array[child]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}
void HeapSort(int *array, int size)//堆排序
{
	//1.创建堆
	int root = (size - 2) >> 1;//size-2 = size-1-1
	for (; root >= 0; root--)
	{
		Adjust(array, size, root);
	}
	//2.堆排序
	size_t end = size - 1;
	while (end != 0)
	{
		swap(array[0], array[end]);//交换堆顶元素和最后一个元素
		Adjust(array, end, 0);
		end--;
	}
}