第三章 ：查詢與排序-------3.6快排在工程實踐中的優化

未優化的快速排序：

T（n）=2T（n/2）+O(n)。

演算法時間複雜度：O（nlgn）。

---

當主元沒選好：（最大/最小）：

時間複雜度： O（n²）。

---

三點中值法：

優化： 在p、r、mid之間，選一箇中間值作為主元

#include<iostream>
using namespace std;
 
//三點中值法 
int partition(int A[],int p,int r){
	
	//優化： 在p、r、mid之間，選一箇中間值作為主元
	int midIndex=p+((r-p)>>1); //中間下標
	int midValueIndex=-1; //中值的下標
	if(A[p]<=A[midIndex]&&A[p]>=A[r]){
		midValueIndex=p;
	} 
	else if(A[r]<=A[midIndex]&&A[r]>=A[p]){
		midValueIndex=r;
	} 
	 else{
	 	midValueIndex=midIndex;
	 }
	swap(A[p],A[midValueIndex]);
	int pivot=A[p];
	
	int left=p+1;//掃描指標 
	int right=r; //右側指標 

	
	while(left<=right){
		//left不停往右走，直到遇到大於主元的元素
		while(A[left]<=pivot) left++;   //迴圈退出時，left一定是指向第一個大於主元的位置 
		while(A[right]>pivot) right--;   //迴圈退出時，right一定是指向最後一個小於等於主元的位置 
		if(left<right){
			swap(A[right],A[left]);	
		}			
	} 
	//while退出時，兩者交錯，且right指向的是最後一個小於等於主元的位置，也就是主元應該待的位置 
	swap(A[p],A[right]);
	
	return right;		
}
 
void quickSort(int A[],int p, int r){
	if(p<r){
		int q=partition(A,p,r);
		quickSort(A,p,q-1);
		quickSort(A,q+1,r); 
	}
} 
 
int main(){
	int arr[]={1,6,2,3,4,8,11,3,9,4,2,5,3};
	quickSort(arr,0,12);
	for(int i=0;i<13;i++){
		cout<<arr[i]<<" ";
	}
 
	return 0;
}

結果：

---

絕對中值法：

//獲取絕對的中值數，，O（N）的樣子
int getMedian(int arr[],int p,int r){   //p:首下標； r：最後一個下標 
	int size=r-p+1; //陣列長度
	
	//每五個元素一組, groupSize:組數 
	int groupSize=(size%5==0)?(size/5):(size/5+1);
	
	//儲存各小組的中值
	int medians[groupSize];
	
	int indexOfMedians=0;  //中值陣列medians 的下標 
	
	//對每一組進行插入排序
	for(int j=0;j<groupSize;j++){
		//單獨處理最後一組，因為最後一組可能不滿5個元素 
		if(j=groupSize-1){
			insertionSort(arr , low: p+j*5 , high: r); //對最後一組進行插入排序 
			medians[indexOfMedians++]=arr[(p+j*5+r)/2]; //最後一組的中間的那個元素 
		}
		else{
			insertionSort(arr , low: p+j*5 , high: p+j*5+4);//對非最後一組進行插入排序
			medians[indexOfMedians++]=arr[p+j*5+2]; //當前組（排序後）的中間的那個 
		} 
	} 
	//對medians排序
	insertSort(medians,0,medians.length-1); //PS: C++對陣列不能用 陣列.length(), 對string可以 
	return medians[medians.length/2]; 
} 

求出中值後，只需和第一個元素交換，後面程式碼相同。

---

待排序列表較短時，用插入排序

PS：n<=8; 插入排序（ O(n(n-1)/2) ）比快速排序( O(2n(lgn+1)) )要快。

n<=8, 插入排序；  否則，快速排序。