八大經典排序（二）

直接選擇排序:

在元素集合array[i]–array[n-1]中選擇關鍵碼最大(小)的數據元素
若它不是這組元素中的最後一個(第一個)元素，則將它與這組元素中的最後一個（第一個）元素交換在剩餘的array[i]–array[n-2]（array[i+1]–array[n-1]）集合中，重複上述步驟，直到集合剩餘1個元素

實現代碼：

void SelectSort(int *parray, int n)
{
	int begin = 0, end = n - 1;
	while (begin < end)//數組比較已經到中間位置已經確定了數組最大值最小值
	{
		for (int i = begin; i <= end; i++)//當前數組沒有確定的數組元素下標
		{
			if (parray[i] > parray[end])
			{
				Swap(&parray[i], &parray[end]);
			}
			else if (parray[i] < parray[begin])
			{
				Swap(&parray[i], &parray[begin]);
			}
		}
		begin++, end--;//確定後下此數組的下標減少
	}
}

直接選擇排序的特性總結：

1. 直接選擇排序思考非常好理解，但是效率不是很好。實際中很少使用
2. 時間複雜度：O(N^2)
3. 空間複雜度：O(1)
4. 穩定性：不穩定

堆排序

堆排序(Heapsort)是指利用堆積樹（堆）這種數據結構所設計的一種排序算法，它是選擇排序的一種。它是通過堆來進行選擇數據。需要注意的是排升序要建大堆，排降序建小堆。

重複繼續調整結果爲

實現代碼：

void AdjustHeapSort(int *a, int n, int parent)//向下調整算法
{
	assert(a);
	int child = parent * 2 + 1;//左孩子
	int temp = 0;
	while (child < n)
	{
		if ((child + 1 < n) && a[child + 1] > a[child])//判斷右孩子是否大於左孩子
		{
			++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)
{
	assert(a);

	//建大堆
	for (int i = (n - 2) / 2; i >= 0; i--)
	{
		AdjustHeapSort(a, n, i);
	}

	//選數
	int end = n - 1;
	while (end>0)
	{

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

		AdjustHeapSort(a, end, 0);
		end--;
	}
}

直接選擇排序的特性總結：

1. 堆排序使用堆來選數，效率就高了很多。
2. 時間複雜度：O(N*logN)
3. 空間複雜度：O(1)
4. 穩定性：不穩定

冒泡排序

實現代碼：
兩兩比較相鄰記錄的關鍵字，如果反序則交換，直到沒有反序的記錄爲止。冒泡的實現在細節上可以很多種變化，我們就最簡單的一種冒泡實現代碼，來講解冒泡排序的思想。

void BubbleSort(int *parray, int n)
{
	int i = 0, t = 0;
	int flag = 0;
	for (i = 0; i < n; i++)
	{
		for (t = 1; t < n; t++)
		{
			if (parray[t - 1]>parray[t])
			{
				int p = 0;
				p = parray[t];
				parray[t] = parray[t - 1];
				parray[t - 1] = p;
				flag = 1;
			}

		}
		if (flag == 0)
		{
			break;
		}
	}
}

冒泡排序的特性總結：

1. 冒泡排序是一種非常容易理解的排序
2. 時間複雜度：O(N^2)
3. 空間複雜度：O(1)
4. 穩定性：穩定