选择排序之直接选择排序和堆排序

选择排序

基本思想：每一次从待排序的数据中选出最小(或最大)的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完。

直接选择排序

1. 在元素集合array[i]--array[n-1]中选择关键码最大(小)的数据元素
2. 若它不是这组元素中的最后一个(第一个)元素，则将它与这组元素中的最后一个(第一个)元素交换
3. 在剩余的array[i]--array[n-2]（array[i+1]--array[n-1]）集合中，重复上述步骤，直到集合剩余1个元素

 代码实现：

void Swap(int* x1, int* x2)
{
	int tmp = *x1;
	*x1 = *x2;
	*x2 = tmp;
}
void SelectSort(int* a, int n)
{
	assert(a);

	int begin = 0;
	int end = n - 1;
	while (begin < end)
	{
		int minindex = begin, maxindex = begin;
		for (int i = begin; i <= end; i++)
		{
			if (a[i] > a[maxindex])
			{
				maxindex = i;
			}
			if (a[i] < a[minindex])
			{
				minindex = i;
			}
		}
		Swap(&a[begin], &a[minindex]);
		if (begin == maxindex)//修正
		{
			maxindex = minindex;
		}
		Swap(&a[end], &a[maxindex]);
		++begin;
		--end;
	}
}
void PrintArray(int* a, int n)
{
	for (int i = 0; i < n; ++i)
	{
		printf("%d ", a[i]);
	}
	printf("\n");
}
int main()
{
	int a[] = { 53, 17, 78, 9, 45, 65, 87, 23, 31 };
        SelectSort(a, sizeof(a) / sizeof(a[0]));
        PrintArray(a, sizeof(a) / sizeof(a[0]));
	return 0;
}

 运行结果如下：

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

1. 直接选择排序非常好理解，但是效率不是很好。实际中很少使用
2. 时间复杂度：O(N^2)
3. 空间复杂度：O(1)
4. 稳定性：不稳定

堆排序

堆排序(HeapSort)是利用堆积树(堆)这种数据结构设计的一种排序算法，他是选择排序的一种。他是通过堆来进行选择数据

需要注意的是排升序要建大堆，排降序建小堆

升序-建大堆

代码实现：

void Swap(int* x1, int* x2)
{
	int tmp = *x1;
	*x1 = *x2;
	*x2 = tmp;
}

void AdJustDown(int* a, int n, int root)
{
	int parent, child;
	assert(a);
	parent = root;
	child = root * 2 + 1;
	while (child < n)
	{
		if (child + 1 < n && a[child] < a[child + 1])
		{
			child++;
		}
		if (a[child] > a[parent])
		{
			Swap(&a[child], &a[parent]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
			break;
	}
}
void HeapSort(int* a, int n)
{
	//建大堆
	int i = 0;
	for (i = (n - 2) / 2; i >= 0; --i)
	{
		AdJustDown(a, n, i);
	}
	int end = n - 1;
	while (end > 0)
	{
		Swap(&a[0], &a[end]);
		//调堆 选次大的数
		AdJustDown(a, end, 0);
		--end;
	}
}
void PrintArray(int* a, int n)
{
	for (int i = 0; i < n; ++i)
	{
		printf("%d ", a[i]);
	}
	printf("\n");
}

int main()
{
	int a[] = { 53, 17, 78, 9, 45, 65, 87, 23, 31 };
	HeapSort(a, sizeof(a) / sizeof(a[0]));
	PrintArray(a, sizeof(a) / sizeof(a[0]));
	return 0;
}

运行结果如下：

 

堆排序的特性总结：

1. 堆排序使用堆来选数，效率就高了很多。
2. 时间复杂度：O(N*lgN)
3. 空间复杂度：O(1)
4. 稳定性：不稳定。