快速排序

快速排序的思想：通過一趟排序將資料分割成獨立的兩部分，其中一部分資料都比另一部分的所有資料都要小，然後再按照此方法對這兩部分資料分別進行快速排序，可以遞迴的進行。

時間複雜度：

• 好的情況(無序的)：O(nlog2n)
• 壞的情況(有序的)：O(n^2) 

讓我們先通過一個例子來了解一下：

12    5    4   25    10    15

首先：我們選擇 12 為基準，比 12 小的放左邊。

5     4    10    12    25    15

同樣，用快速排序對 12 的前半部分進行排序：

4    5    10    12    25    15

此時，前半部分排序完畢，後半部分一樣用快速排序：

4    5    10    12    15    25

我們可以用遞迴的方法來求解。

下面我們換個例子來深入的理解快速排序演算法。

23  4  34  54  65  76  22  3  56  13  35  28  32  43  5

如下圖所示，為第一趟的快速排序。

此時，23 的前半部分都比 23 小，23 的後半部分都比 23 大。

我們可以對它的前半部分和後半部分分別進行快速排序，直到排序結束。

下面我們用 java 來實現快速排序演算法。

public static void quickSort(int[] array){
	Quick(array,0,array.length -1);
}
 

public static void Quick(int[] array,int start,int end){
	int par = partion(array,start,end);
	if(par > start + 1){
		Quick(array,start,par-1);//對前半段進行快速排序
	}
	if(par < end-1){
		Quick(array,par+1,end);	//對後半段進行快速排序。
	}
}

下面這個函式是返回基準位置的。即上面的例子中第一趟快速排序後 23 的位置。 

public static int partion(int[] array,int start,int end){
	int tmp = array[start];
	while(start < end){
		while(start < end && array[end] >= tmp){
			--end;
		}
		if(start >= end){
			break;
		}else{
			array[start] = array[end];
		}
		while(start < end && array[start] <= tmp){
			++start;
		}
		if(start >= end){
			break;
		}else{
			array[end] = array[start];
		}
	}
	array[start] = tmp;
	return start;
}
 

這是我們用遞迴來解決它，其實還有另外一種辦法，我們可以利用棧來解決這個問題。

還是上面的例子，讓我們來分析一下。

23  4  34  54  65  76  22  3  56  13  35  28  32  43  5

首先：我們來給來個快速排序，將它分成兩部分。

5  4  13  23  22  23  76  65  56  54  35   28  32  43  34

然後：和前面一樣，我們分別對左邊和右邊進行快速排序，但不同的是，這次我們要把下標 start 和 end 存入棧中，然後將右邊的下標 start 和 end 也存入棧中。

如圖

接著我們從棧裡取出，使 low 和 high 分別指向 start 和 end ,然後進行快速排序。

依次類推，我們一邊向棧裡取出元素，一邊向棧裡儲存元素，直到棧為空，表示我們的排序結束。

下面我們用 java 實現一下這個非遞迴的。

public static void QuickSort(int[] array){
	int[] stack = new int[array.length];
	int top = 0;
	int low = 0;
	int high = array.length -1;
	int par = partion(array,low,high);
	//入棧
	if(par > low+1){
		stack[top++] = low;
		stack[top++] = par-1;
	}
	if(par < high-1){
		stack[top++] = par+1;
		stack[top++] = high;
	}
	//出棧
	while(top > 0){
		high = stack[--top];
		low = stack[--top];
		par = partion(array,low,high);
		if(par > low+1){
			stack[top++] = low;
			stack[top++] = par-1;
		}
		if(par < high-1){
			stack[top++] = par+1;
			stack[top++] = high;
		}
	}	

快速排序的優化

快速排序有以下優化方案

1. 當待排序陣列當中資料比較少的時候，用直接插入法。
2. 聚集相同元素法。
3. 隨機選取基準法。

當資料比較少時，採用直接插入法排序

當資料比較少時，採用直接插入法排序比較高效。

所以我們只需要在快速排序的方法上增加一個判斷語句即可

以下為用 java 實現

public static void Quick1(int[] array,int start,int end){
		//當資料少於 100 時用直接插入法排序即可
		if((end - start + 1) < 100){
			insertSort(array,start,end);
			return;
		}
		int par = partion(array,start,end);
		if(par > start + 1){
			Quick1(array,start,par-1);
		}
		if(par < end-1){
			Quick1(array,par+1,end);
		}
	}

聚集相同元素法

簡單來說就是找和基準相同的元素，這樣子可以減少遞迴的次數。

下面是把和基準相同的元素聚集到一起。

這裡附上程式碼

    public static int[] focus(int[] array,int start,int end,int par,int left,int right){
		//聚集和基準相同的元素
		//左邊找
		int parleft = par-1;
		int parright = par + 1;
		for(int i = par-1;i >= start;i--){
			if(array[i] == array[par]){
				if(i != parleft){
					swap(array,i,parleft);
					parleft--;
				}else{
					parleft--;
				}
			}
		}
		left = parleft;
		//右邊找
		for(int j = par+1;j <= end;j++){
			if(array[j] == array[par]){
				if(j != parright){
					swap(array,j,parright);
					parright++;
				}else{
					parright++;
				}
			}
		}
		right = parright;
		int[] brray = new int[2];
		brray[0] =left;
		brray[1] = right;
		return brray;
	}

然後我們對於基準左邊和基準右邊分別進行排序，和優化前不同的是我們不用再比較和基準相同的元素了。

對於左邊，我們令 low = 0,high = pl-1。

對於右邊，我們令 low = pr-1, high = 長度-1。

public static void Quick2(int[] array,int start,int end){
		int par = partion(array,start,end);
		int  left = par-1;
		int right = par+1;
		int[] b = focus(array,start,end,par,left,right);
		left = brrar[0];
		right = brrar[1];
		if(par > start + 1){
			Quick2(array,start,left);
		}
		if(par < end-1){
			Quick2(array,right,end);
		}
	}

隨機選取基準法。

在資料已經有效的情況下，快速排序時間複雜度太高，為了解決這個問題，課一隨機選取基準來提高效率。

public static void Quick3(int[] array,int start,int end){
		int par = partion(array,start,end);
		//假設已經有序，就會提高效率
		swap(array, start, (int)(Math.random()*10%(end-start))+start);
		if(par > start + 1){
			Quick(array,start,par-1);
		}
		if(par < end-1){
			Quick(array,par+1,end);
		}
	}