常见排序算法——选择排序

基本思想：
每一趟(第i趟，i=0,1，…，n-2)在后面n-i个待排序的数据元素集合中选
出关键码最小的数据元素，作为有序元素序列的第i个元素。待到第n-2趟
做完，待排序元素集合中只剩下1个元素，排序结束
【直接选择排序】
在元素集合array[i]–array[n-1]中选择关键码最大(小)的数据元素
若它不是这组元素中的最后一个(第一个)元素，则将它与这组元素中
的最后一个（第一个）元素交换
在剩余的array[i]–array[n-2]（array[i+1]–array[n-1]）集合中，
重复上述步骤，直到集合剩余1个元素

直接选择排序的时间复杂度为O(n^2 )； 它是一种不稳定的排序算法

每次只能标记一个最大的元素，效率比较低

void SelectSort(int* array, int size)
{
		int i = 0;
		for (i = 1; i < size; ++i)
		{
				if(array[i] < array[i-1]
				{
						int j = i - 1;
						int tmp = array[i];
						while(tmp < array[j])
						{
								array[j+1] = array[j];
								j--;
						}
						array[j+1] = tmp;
				}
		}
}

优化后的选择排序：
每次可以标记两个元素，一个最大的元素和一个最小的元素，效率相对能高点

void SelectSort_OP(int* array, int size)
{
	int begin = 0;
	int end = size - 1;

	while (begin < end)
	{
		int MaxPos = begin;
		int MinPos = begin; 
		int j = begin + 1;

		while (j <= end)
		{
			if (array[j] > array[MaxPos])
				MaxPos = j;

			if (array[j] < array[MinPos])
				MinPos = j;

			++j;
		}
		if (MaxPos != end)
			Swap(&array[MaxPos], &array[end]);

		if (MinPos == end)
			MinPos = MaxPos;

		if (MinPos != end)
			Swap(&array[MinPos], &array[begin]);

		++begin;
		--end;
	}
}

【堆排序算法】
创建堆：升序—>大堆，降序—>小堆

执行如下步骤，直到数组为空
(1)把堆顶array[0]元素和当前最堆的最后一个元素交换
(2)堆元素个数减1
(3)由于第1步后根节点不再满足最堆定义，向下调整根结点

把一棵完全二叉树调整为堆，以及每次将堆顶元素交换后
进行调整的时间复杂度均为O( log2n)，所以,
堆排序的时间复杂度为：O( n * log2n)
堆排序是一种不稳定的排序算法

void HeapSort(int* array, int size) //升序，需要用大堆
{

	//创建堆
	CreatHeap(array, size);
	while (size > 0)
	{
		//交换堆顶元素和最后一个元素
		Swap(&array[0], &array[size - 1]);
		//交换后不满足堆的性质，重新调整
		AdjustHeap(array, size, 0);
	}
}

void CreatHeap(int* array, int size)
{
	int i = 0;
	for (i = size; i >= 0; i--)
		AdjustHeap(array, size, i);
}

void AdjustHeap(int* array, int size, int parent)
{
	int Lchild = 2 * parent + 1;
	int Rchild = 2 * parent + 2;

	int Max = parent;

	//若左孩子大于双亲节点，就把左孩子标记为最大节点
	if (Lchild <= size && array[Max] < array[Lchild])
		Max = Lchild;

	//若右孩子大于双亲节点，就把右孩子标记为最大节点
	if (Rchild <= size && array[Max] < array[Rchild])
		Max = Rchild;

	//若最大节点不是双亲节点，那就将双亲节点和最大节点进行交换，继续调整
	if (Max != parent)
	{
		Swap(&array[Max], &array[parent]);
		AdjustHeap(array, size, Max);
	}

}

交换函数

void Swap(int* pLeft, int* pRight)
{
	int tmp;
	assert(pLeft);
	assert(pRight);

	tmp = *pLeft;
	*pLeft = *pRight;
	*pRight = tmp;
}

打印函数

void print(int* array, int size)
{
	int i = 0;
	for (i = 0; i < size; ++i)
		printf("%d ", array[i]);
	printf("\n");
}

测试函数 test.c

#include "SelectSort.h"

int main()
{
	int array[] = { 2, 0, 4, 9, 3, 6, 8, 7, 1, 5 };
	int size = sizeof(array) / sizeof(array[0]);

	//选择排序
	//SelectSort(array, size);

	//SelectSort_OP(array, size);

	//堆排序
	HeapSort(array, size);
	print(array, size);

	system("pause");
	return 0;
}