1.簡單選擇排序

（1）本質：每一趟從給定待排序序列A[ 1......n ] ，選擇出第i小元素，並和A[i]交換。

程式碼：

/*************************************************
演算法：簡單選擇排序(升序)
時間複雜度為O（n^2）
**************************************************/
void simpleSelectSort(int *arr , int len)
{
	for(int i =0;i<len-1;i++)
	{
		int minIndex=i;  //輔助交換記憶體空間
		for (int j=i+1;j<len;j++)
		{
			if (arr[j]<arr[minIndex])
			{
				minIndex=j;
			}
		}
		if(minIndex != i)
			swap(&arr[i],&arr[minIndex]);
		cout<<"第"<<i+1<<"趟：";
		printArr(arr,len);
		cout<<endl;
	}
}
 

（2）效能分析

     簡單選擇排序記錄移動操作次數較少，這點優於氣泡排序。有兩層迴圈，所以時間複雜度為O（n^2）

2.堆排序

      n個元素的序列{k₁，k₂，…,k_n}當且僅當滿足下列關係之一時，稱之為堆。

　　情形1：k_i<= k_2i且k_i<= k_2i+1（最小化堆或小頂堆）

　　情形2：k_i>= k_2i且k_i>= k_2i+1（最大化堆或大頂堆）

　　其中i=1,2,…,n/2向下取整;

2.2 堆排序（以大頂堆為例，根節點從0開始）

     輸出堆頂最大值之後，使得剩餘n-1個元素的序列重建一個堆；如此反覆執行，便能得到一個有序序列，這個過程稱之為堆排序。（升序---大頂堆，降序---小頂堆）

（1）堆的儲存

　一般用陣列來表示堆，若根結點存在序號0處， i結點的父結點下標就為(i-1)/2。i結點的左右子結點下標分別為2*i+1和2*i+2。

　　（注：如果根結點是從1開始，則左右孩子結點分別是2i和2i+1。）

最大化堆如下：

實現堆排序需要解決兩個問題：

　　　　1.如何由一個無序序列建成一個堆？

　　　　2.如何在輸出堆頂元素之後，調整剩餘元素成為一個新的堆？

帥選過程程式碼：

/****************************************************
堆排序是一種選擇排序；在最壞的情況下，其時間複雜度也為O(nlogn)
其執行時間主要耗費在建初始堆和調整建新堆時進行的反覆“篩選”上
****************************************************/
/*
函式功能：當堆的某一個節點破壞了堆的性質，呼叫此函式進行調整剩餘的元素，使其為新堆
k      ：k節點破壞了堆的性質
*/
void maxHeap(int *arr,int len,int k)
{
	//遞迴邊界條件
	if (k>len/2-1)   //最後一個非葉子節點的下標為len/2-1;
	{
		return;
	}
	//1.比較k節點左右孩子的值,找出左右孩子的較大值
	int i=0;  
	//因為假設根結點的序號為0而不是1，所以i結點左孩子和右孩子分別為2i+1和2i+2
	if ((2*k+2<=len-1)&&arr[2*k+1]<arr[2*k+2])
		i=2*k+2;
	else if(2*k+1<=len-1)
		i=2*k+1;
	if (arr[k]<arr[i])
	{
		swap(&arr[k],&arr[i]);
		maxHeap(arr,len,i);
	}
}

問題1：構建初始堆

     構建堆就是對所有的非葉子節點進行篩選。最後一個非葉子節點的下標為([n/2]-1),所以篩選只需從([n/2]-1)節點開始，自下向上的進行調整，直到堆頂。

/*****************************************************************************
1.給定一個數組，首先根據該陣列元素構造一個完全二叉樹。
2.從最後一個非葉子結點開始，每次都是從父結點、左孩子、右孩子中進行比較交換;
3.交換可能會引起孩子結點不滿足堆的性質，所以每次交換之後需要重新對被交換的孩子結點進行調整。
最後一個非葉子節點下標：[n/2]-1 （根節點的下標為0）， n表示節點個數
******************************************************************************/
void createHeap(int *arr , int len)
{
	//最大堆----------自下向上調整,陣列的下標從0開始
	for (int i=len/2-1;i>=0;i--)
	{
		maxHeap(arr,len,i);
	}
}

（3）堆排序

     首先輸出堆頂元素（因為它是最值），將堆頂元素和最後一個元素交換，這樣，第n個位置（即最後一個位置）作為有序區，前n-1個位置仍是無序區，對無序區進行調整，得到堆之後，再交換堆頂和最後一個元素，這樣有序區長度變為2。不斷進行此操作，將剩下的元素重新調整為堆，然後輸出堆頂元素到有序區。每次交換都導致無序區-1，有序區+1。不斷重複此過程直到有序區長度增長為n-1，排序完成。

void heapSort(int *arr , int len)
{
	//1. 構建堆
	createHeap(arr,len);
	//2.堆排序
	for (int i=0;i<len-1;i++)
	{
		//堆頂元素與最後一個元素交換
		swap(&arr[0],&arr[len-1-i]);
		//調整堆，堆頂破壞了堆的性質
		maxHeap(arr,len-i-1,0);
	}
}

（4）反思堆排序

     仔細回想一下篩選法調整堆的過程我們發現，第i次調整堆，其實就是把A中的第i大元素放到首位置A[0]，然後A[0]和A[n-i-1]互換.這樣A[(n-i-1)...n]就已經有序，於是又把A[0...n-i-2]看成一個堆再進行排序，如此重複。調整堆不就是選擇出待排序序列中的最大值嗎？所以堆排序的本質和選擇排序的本質是一樣的。選擇一個待排序序列中的最小（大）值，這就是選擇排序的本質。所以，堆排序是一種選擇排序。

（5）效能分析

    堆排序時間=建堆時間+調整堆時間。從上文中知道建堆時間複雜度為O（n*log2n）。篩選法調整堆（maxHeap函式）時間O（log2n），總共迴圈了n-1次maxHeap函式，所以調整堆時間複雜度為O（n*log2n）。得出堆排序時間複雜度O（n*log2n）。且在最壞情況下時間複雜度也是O（n*log2n）。此外堆排序是不穩定的原地排序演算法。

void test()
{
	int arr[]={16,20,8,7,17,3,30,1,51,9,6};
	int len = sizeof(arr)/sizeof(int);
	cout<<"排序前：";
	printArr(arr,len);
	cout<<endl;

	//簡單選擇排序
	simpleSelectSort(arr,len);
	cout<<"簡單選擇排序：";
	printArr(arr,len);
	cout<<endl;

	//堆排序
	heapSort(arr , len);
	cout<<"堆排序：";
	printArr(arr,len);
	cout<<endl;
}

void swap(int *p,int *q)
{
	int tmp;
	tmp =*p;
	*p = *q;
	*q = tmp;
}
void printArr(int *arr,int len)
{
	for (int i=0;i<len;i++)
	{
		cout<<arr[i]<<" ";
	}
	cout<<endl;
}