【源碼共享】快速排序算法的幾種實現方式

快速排序算法的基本特性
時間複雜度：O（n*lgn）
最壞：O（n^2）
空間複雜度：O（n*lgn）
不穩定。

快速排序是一種排序算法，對包含n個數的輸入數組，平均時間爲O（nlgn），最壞狀況是O（n^2）。
一般是用於排序的最佳選擇。由於，基於比較的排序，最快也只能達到O（nlgn）。

在平均情況下，排序 n 個項目要Ο(n log n)次比較。在最壞情況下則須要Ο(n2)次比較，但這種情況並不常見。事實上，快速排序一般明顯比其餘Ο(n log n) 算法更快，由於它的內部循環（inner loop）能夠在大部分的架構上頗有效率地被實現出來。

快速排序使用分治法（Divide and conquer）策略來把一個串行（list）分爲兩個子串行（sub-lists）。

算法步驟：

1. 從數列中挑出一個元素，稱爲 「基準」（pivot），

2. 從新排序數列，全部元素比基準值小的擺放在基準前面，全部元素比基準值大的擺在基準的後面（相同的數能夠到任一邊）。在這個分區退出以後，該基準就處於數列的中間位置。這個稱爲分區（partition）操做。

3. 遞歸地（recursive）把小於基準值元素的子數列和大於基準值元素的子數列排序。

遞歸的最底部情形，是數列的大小是零或一，也就是永遠都已經被排序好了。雖然一直遞歸下去，可是這個算法總會退出，由於在每次的迭代（iteration）中，它至少會把一個元素擺到它最後的位置去。

首先簡單描述下快速排序的基本思路

快速排序是基於分治模式處理的，對一個典型子數組A[p…r]排序的分治過程爲三個步驟：

1.分解：

A[p..r]被劃分爲倆個（可能空）的子數組A[p ..q-1]和A[q+1 ..r]，使得

A[p ..q-1] <= A[q] <= A[q+1 ..r]

2.解決：經過遞歸調用快速排序，對子數組A[p ..q-1]和A[q+1 ..r]排序。

3.合併。

實現代碼以下

代碼一：

#include <stdio.h>

// 一趟排序過程
int partition(int *arr, int low, int high)
{
	int pivot = arr[high];//選最右邊元素爲基準
	int i = low - 1;//j爲遊標，i爲本趟排序後位置
	int j, tmp;

	for (j = low; j<high; ++j)//從左向右依次檢查
	    if (arr[j]<pivot)
		{
		    tmp = arr[++i];
		    arr[i] = arr[j];
		    arr[j] = tmp;
	    }

	tmp = arr[i + 1];//將基準元素歸位
	arr[i + 1] = arr[high];
	arr[high] = tmp;

	return i + 1;//返回基準元素的最終位置
}

//排序算法過程:分治思想，將左右兩部分分別遞歸
void quick_sort(int *arr, int low, int high)
{
	if (low<high){
		int mid = partition(arr, low, high);
		quick_sort(arr, low, mid - 1);
		quick_sort(arr, mid + 1, high);
	}
}


int main()
{
	int arr[10] = { 1, 4, 6, 2, 5, 8, 7, 6, 9, 12 };//測試數據
	int i;
	quick_sort(arr, 0, 9);
	for (i = 0; i<10; ++i)
		printf("%d ", arr[i]);

	getchar();
}

排序結果：

代碼二：

#include <stdio.h> 

int a[101], n;//定義全局變量，這兩個變量須要在子函數中使用 

void quicksort(int left, int right)
{
	int i, j, t, temp;
	if (left>right)
		return;

	temp = a[left]; //temp中暫存基準數 
	i = left;
	j = right;
	while (i != j)
	{
		//順序很重要，要先從右邊開始找，找比基準數小的數值
		while (a[j] >= temp && i<j)
			j--;
		//再找左邊的，找比基準數大的數值
		while (a[i] <= temp && i<j)
			i++;
		//交換兩個數在數組中的位置 
		if (i<j)
		{
			t = a[i];
			a[i] = a[j];
			a[j] = t;
		}
	}
	//最終將基準數歸位 
	a[left] = a[i];
	a[i] = temp;

	quicksort(left, i - 1);//繼續處理左邊的，這裏是一個遞歸的過程 
	quicksort(i + 1, right);//繼續處理右邊的 ，這裏是一個遞歸的過程 
}

int main()
{
	int i;
	//讀入數據 
	printf("please input the length of array sorted:");
	scanf_s("%d", &n);
	printf("please input the number of array element sorted:\n");
	for (i = 1; i <= n; i++)
		scanf_s("%d", &a[i]);
    //快速排序調用 
	quicksort(1, n);
	//輸出排序後的結果 
	for (i = 1; i <= n; i++)
		printf("%d ", a[i]);

	getchar();//消除回車符
	getchar();//等待輸入
	return 0;
}

排序結果：

代碼三：本改進算法中,只對長度大於k的子序列遞歸調用快速排序,讓原序列基本有序，而後再對整個基本有序序列用插入排序算法排序

#include<stdio.h>

void print(int a[], int n){
	for (int j = 0; j<n; j++){
		printf("%d  ",a[j]);
	}
	printf("\n");
	return;
}

void swap(int *a, int *b)
{
	int tmp = *a;
	*a = *b;
	*b = tmp;
}

// 一次排序過程
int partitions(int a[], int low, int high)
{
	int privotKey = a[low];					 //基準元素
	while (low < high)                       //從表的兩端交替地向中間掃描
	{					    
		while (low < high  && a[high] >= privotKey) //從high 所指位置向前搜索，至多到low+1 位置。將比基準元素小的交換到低端
			--high; 
		swap(&a[low], &a[high]);
		while (low < high  && a[low] <= privotKey) 
			++low; 
		swap(&a[low], &a[high]);
	}
	print(a, 10);                            //輸出每次排序結果
	return low;
}

// 改進算法：僅當每段長度大於k時，進行一次快速排序
void qsort_improve(int r[], int low, int high, int k){
	if (high - low > k)                      //長度大於k時遞歸, k爲指定的數
	{
		int pivot = partitions(r, low, high); // 調用的Partition算法保持不變
		qsort_improve(r, low, pivot - 1, k);
		qsort_improve(r, pivot + 1, high, k);
	}
}

//遞歸進行地快速排序
void quickSort(int r[], int n, int k)
{
	//先調用改進算法Qsort使之基本有序
	qsort_improve(r, 0, n, k);

	//再用插入排序對基本有序序列排序
	int i, j,temp;
	for (i = 1; i <= n; i++)//由於當i=0時，無心義，故從下標1開始
	{
		temp = r[i];
		j = i - 1;
		while (temp<r[j])//升序
		{
			r[j + 1] = r[j];
			j--;
			r[j + 1] = temp;
		}
	}
}

void main()
{
	int a[10] = { 3, 1, 5, 7, 2, 4, 9, 6, 10, 8 };
	printf("初始值：");
	print(a, 10);
	quickSort(a, 9, 4);
	printf("排序後：");
	print(a, 10);

	getchar();
}

排序結果：

 

算法複雜度

最壞狀況下的快排時間複雜度：

最壞狀況發生在劃分過程產生的倆個區域分別包含n-1個元素和一個0元素的時候，
即假設算法每一次遞歸調用過程當中都出現了，這種劃分不對稱。那麼劃分的代價爲O（n），
由於對一個大小爲0的數組遞歸調用後，返回T（0）=O（1）。
估算法的運行時間能夠遞歸的表示爲：

T（n）=T（n-1）+T（0）+O（n)=T(n-1)+O(n).

能夠證實爲T（n）=O（n^2）。

所以，若是在算法的每一層遞歸上，劃分都是最大程度不對稱的，那麼算法的運行時間就是O（n^2）。

最快狀況下快排時間複雜度：

最快狀況下，即PARTITION可能作的最平衡的劃分中，獲得的每一個子問題都不能大於n/2.

由於其中一個子問題的大小爲|n/2|。另外一個子問題的大小爲|-n/2-|-1.

在這種狀況下，快速排序的速度要快得多：

T(n)<=2T（n/2）+O（n）.能夠證得，T（n）=O（nlgn）。