詳解C語言快速排序三種方法的單趟實現

Posted on by

交換排序的思想

基本思想：所謂交換，就是根據序列中兩個記錄鍵值的比較結果來對換這兩個記錄在序列中的位置，交換排 序的特點是：將鍵值較大的記錄向序列的尾部移動，鍵值較小的記錄向序列的前部移動。

冒泡排序的思想

冒泡排序比較簡單，我們之前使用也很多，簡單講解，就是比較兩個數，如果比他大就交換，沒有他大就接著向後比，一直到數組結束，這是單趟排序，多趟就是控制好下標，進行循環即可。

冒泡代碼實現

void Swap(int* p1, int* p2)
{
	int tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}
 
 
void BubbleSort(int* a, int n)
{
	assert(a);
 
	for (int j = 0; j < n - 1; ++j)
	{
		int exchange = 0;//定義變量，用於判斷是否交換過
		for (int i = 1; i < n - j; ++i)
		{
			if (a[i - 1] > a[i])
			{
				Swap(&a[i - 1], &a[i]);
				exchange = 1;
			}
		}
 
		if (exchange == 0)//沒有交換過表示有序，直接跳出
		{
			break;
		}
	}
}

冒泡排序的特性

1. 冒泡排序是一種非常容易理解的排序

2. 時間復雜度：O(N^2)

3. 空間復雜度：O(1)

4. 穩定性：穩定

快速排序的整體框架

快速排序是Hoare於1962年提出的一種二叉樹結構的交換排序方法，其基本思想為：任取待排序元素序列中 的某元素作為基準值，按照該排序碼將待排序集合分割成兩子序列，左子序列中所有元素均小於基準值，右 子序列中所有元素均大於基準值，然後最左右子序列重復該過程，直到所有元素都排列在相應位置上為止。

// 假設按照升序對array數組中[left, right)區間中的元素進行排序
void QuickSort(int array[], int left, int right)
{
 if(right - left <= 1)
 return;
 
 // 按照基準值對array數組的 [left, right)區間中的元素進行劃分
 int div = partion(array, left, right);
 
 // 劃分成功後以div為邊界形成瞭左右兩部分 [left, div) 和 [div+1, right)
 // 遞歸排[left, div)
 QuickSort(array, left, div);
 
 // 遞歸排[div+1, right)
 QuickSort(array, div+1, right);
}

述為快速排序遞歸實現的主框架，發現與二叉樹前序遍歷規則非常像，同學們在寫遞歸框架時可想想二叉 樹前序遍歷規則即可快速寫出來，後序隻需分析如何按照基準值來對區間中數據進行劃分的方式即可。

簡單理解：

我們先選出一個數，然後把所有數據分為三部分，第一部分是大於這個數的部分，第二個部分是這個數，第三個部分是大於這個數的。

然後，進行遞歸求解，對於小於的部分，選一個數，分為三部分。對於大於的部分，選一個數，分為三部分進行求解。

遞歸返回條件：首先是區間不存在返回，區間隻有一個數返回。

快速排序單趟實現邏輯

1. hoare版本單趟實現（左右指針法）

首先我們先學習下最經典的左右指針法：

首先我們一般都會這兩個疑問？（後續挖坑法和前後指針法同理）

1.為什麼要選左邊的數作為初識位置比較位置。

2.為什麼要讓右邊先走？

我們之所以選取左邊，隻是因為方便，容易控制，你也可以選擇右邊，或者任意位置，都可以，隻不過在代碼邏輯上稍微復雜點，不容易控制。

我們讓右邊先走，是因為最後我們要把 key位置的數據移動到相遇位置，也就是key位置數據的正確位置，所以我們應該保證讓左邊來遇到右邊，就是讓右邊的位置先到等著左邊。因為我們選取的是左邊的key，所以左邊的下標就是少瞭 1 ，我們讓右邊先走就可以剛好彌補過來。反之，如果我們選取左邊為key，還讓左邊先走，那麼我們最後就會發現，這個位置的下標就錯瞭，不能保證左邊都是大於key的數瞭。

綜上：我們如果選擇瞭左邊為key，那麼就讓右邊先走，選擇右邊為key，就讓左邊先走。

我們看著示意圖實現下單趟排序代碼：

//前後指針法單趟排序
int PartSort(int *a,int left,int right)
{
	int keyi = left;//先保存最左側下標，作為keyi
 
	while (left < right)
	{
		//先讓右走，找小，並且不能越界
		while (left < right && a[right] >= a[keyi])
		{
			--right;
		}
 
		//再讓左走，找大，不越界。
		while (left < right && a[left] <= a[keyi])
		{
			++left;
		}
 
		//交換左邊大的，和右邊小的
		Swap(&a[left], &a[right]);
	}
 
	//循環完成，我們在最後交換下，相遇位置的和原來keyi位置的值
	Swap(&a[keyi], &a[left]);
 
	//返回相遇位置的下標是為進行下一步遞歸。
	return left;
}

2.挖坑法單趟排序實現

我們看下有點意思的挖坑法。

我們觀察發現，還是先選取一個位置作為我們比較的數同時也是坑位，然後還是先讓右邊走，然後把數據放到坑中，形成一個新的坑，接著左邊走，再把數據放入坑中，形成新坑，最後，把我們選取位置的數據放到最後一個坑位上，就滿瞭。

其實在我們調試發現，"挖坑" 隻不過是形象描述瞭，其實乜有坑位，隻是數據重復，然後替換掉瞭。

圖示比較簡單，我們嘗試實現下單趟排序：

 //挖坑法
int PartSort2(int* a, int left, int right)
{
	int key = a[left];//保存最左邊初始位置的值
 
	while (left < right)
	{
		while (left < right && a[right] >= key)
		{
			--right;
		}
 
		a[left] = a[right];//產生一個坑位
 
		while (left < right && a[left] <= key)
		{
			++left;
		}
 
		a[right] = a[left];//上一個坑位填上，產生新的坑位
	}
 
	a[left] = key;//把最後的坑位填上瞭。
 
	return left;//返回最後相遇的下標，以便後序遞歸
}

3.前後指針法

前後指針法和左右指針類似但是不完全一樣哦。

前後指針法，其實就是定義兩個指針，一個是prev為初始位置，一個是cur為初始位置+1，cur是遇見大於初始位置的值停下，交換（prev+1）下標的值，直到 cur 指針走到結尾，此時就交換prev指針和初始位置即可。

簡單理解：

前後指針，就是不停的把大於初始位置的數據向後移動，最後一個指針走到末尾瞭，另一個指針此時的指向，剛好就是我們初始位置在整個數據中要排的位置。

需要註意的是：我們每次交換的都是prev+1的下標值，如果 prev = cur 時，此時我們不用交換，prev也不用++，隻需要 cur++ 即可。

前後指針的單趟代碼實現：

//前後指針法
int PartSort3(int *a, int left, int right)
{
	int prev = left;//後指針
	int cur = left + 1;//前指針
	int keyi = left;//初始位置
 
	while(cur <= right)//當cur小於等於最右邊時進入循環
	{
		//當cur找到比初始位置大的數，如果此時cur不等於prev，
		//那麼就交換cur和++prev，一定是前置++。
		if (a[cur] < a[keyi] && prev != cur)
		{
			Swap(&a[cur], &a[++prev]);
		}
		cur++;
	}
	Swap(&a[prev], &a[keyi]);//最後交換prev和初始位置即可
 
	return prev;//返回prev為瞭後續遞歸做鋪墊
}

以上就是詳解C語言快速排序三種方法的單趟實現的詳細內容，更多關於C語言快速排序單趟實現的資料請關註WalkonNet其它相關文章！

推薦閱讀：