选择排序和堆排序

选择排序

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

升序：把数组中最大的数与数组最后一个位置的值交换，然后待排序数组长度-1，重复操作，直至全部排完。

#include<iostream>
using namespace std;
void SelectSort(int* arr, int len)
{
	int end = len - 1;
	for (int j = 0; j < len; j++)
	{
		int max = 0;
		for (int i = 0; i <= end; i++)
		{
			if (arr[i]>arr[max])
				max = i;
		}
		swap(arr[max], arr[end]);
		end--;
	}
}
int main()
{
	int arr[] = { 49, 38, 65, 97, 76, 13, 27, 49, 55, 4 };
	int len = sizeof(arr) / sizeof(arr[0]);
	SelectSort(arr, len);
	for (int i = 0; i < len; i++)
		cout << arr[i] << "  ";
	cout << endl;
	system("pause");
	return 0;
}

选择排序的优化

优化：一次找到最大值和最小值，最大值与最后一个元素交换，最小值与第一个元素交换。

#include<iostream>
using namespace std;
void SelectSort(int* arr,int len)
{
	int begin = 0, end = len - 1;
	while (begin < end)
	{
		int max = begin;
		int min = begin;
		for (int i = begin; i <= end; i++)
		{
			if (arr[i]>arr[max])
				max = i;
			if (arr[i] < arr[min])
				min = i;
		}
		if (min == end)//判断最小值是否在最大值要放置的位置
			min = max;
		swap(arr[max], arr[end]);
	
		if (max == begin)//判断最大值是不是在最小值要放置的位置
			max = min;
		swap(arr[min], arr[begin]);
		end--; begin++;
	}
}
int main()
{
	int arr[] = {49,38,65,97,76,13,27,49,55,4};
	int len = sizeof(arr) / sizeof(arr[0]);
	SelectSort(arr,len);
	for (int i = 0; i < len; i++)
		cout << arr[i] <<"  ";
	cout << endl;
	system("pause");
	return 0;
}

容易出错的地方：在进行交换前都要进行判断，最小值处于末尾位置和最大值处于开始位置，都会有影响。

直接选择排序的特性总结

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

堆排序

堆排序(Heapsort)是指利用堆积树（堆）这种数据结构所设计的一种排序算法，它是选择排序的一种。它是通过堆来进行选择数据。需要注意的是排升序要建大堆，排降序建小堆。

利用数组下标之间的关系，将数组想象称为一个完全二叉树，如下图：

采用小堆排降序

1、在小堆的基础上，把arr[0]数组和最后一个元素交换；
2、操作的元素个数-1；
3、由于第一步之后，堆不再是小堆，所以需要向下调整。

把数组调整成堆，以及每次将元素交换后进行调整的时间复杂度都是$O(logN)$,所以堆排序的时间复杂度为：$O(N\ast logN)$，堆排序不稳定。

#include<iostream>
using namespace std;
void Adjustdown(int* arr, int from,int n)//向下调整
{
	int father = from;
	int child = 2 * father + 1;
	while (child<n)
	{
		if (child + 1 < n&&arr[child] > arr[child + 1])
			child++;
		if (child < n&&arr[child] < arr[father])
		{
			swap(arr[child], arr[father]);
			father = child;
			child = 2 * father + 1;
		}
		else
			break;
	}
}

void HeapSort(int* arr, int n)//升序
{
	int FirstNotLeaf = (n - 2) >> 1;//n-1是最后一个结点的下标
	for (int i = FirstNotLeaf; i >= 0; --i)
		Adjustdown(arr, i, n);;// 小堆建成
	
	int j = n - 1;
	while (j>0)
	{
		swap(arr[0], arr[j]);
		--j;
		Adjustdown(arr, 0, j);
	}
}

void TestSort()
{
	int arr[] = { 4,1,3,0,2,5,9,8,6,7 };
	int len = sizeof(arr) / sizeof(int);
	HeapSort(arr, len);
	for (int i = 0; i < len; i++)
		printf("%d ", arr[i]);
	printf("\n");
}

int main()
{
	TestSort();
	system("pause");
	return 0;
}

堆排序的特性总结

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