七大經典排序算法圖解

Posted on by

插入排序

①直接插入排序

基本思想

每次從一個有序序列開始，將待排元素與有序序列中的元素從後往前逐個比較，

若有序序列中的元素大於待排元素，則將較大的元素往後覆蓋；

否則，將待排元素插入其前面，並結束此輪比較。

動圖演示

​

代碼實現

void InsertSort(int* a, int n)
{
	for (int i = 0; i < n - 1; i++)
	{
		int end = i;
		int x = a[end + 1];
		while (end >= 0)
		{
			if (a[end] > x)
			{
				a[end + 1] = a[end];
				end--;
			}
			else
				break;
		}
		a[end + 1] = x;
	}
}

②希爾排序

基本思想

先選定一個整數作為 gap ,將待排序列以 gap 為間隔分成 gap 組，

先對每組進行直接插入排序，

然後再適當縮小 gap ,重復上述步驟。

當 gap = 1 時，此時序列已經進行瞭多次預排序，接近有序。

這時再對序列進行直接插入排序，就能達到優化的效果。

圖示

​

代碼實現

void ShellSort(int* a, int n)
{
	//多次預排序(gap > 1) + 直接插入( gap == 1)
	int gap = n;
	while (gap > 1)
	{
		//使gap最後一次一定能到1
		gap = gap / 3 + 1;
		//多組一起排
		for (int i = 0; i < n - gap; ++i)
		{
			int end = i;
			int x = a[end + gap];
			while (end >= 0)
			{
				if (a[end] > x)
				{
					a[end + gap] = a[end];
					end -= gap;
				}
				else
					break;
			}
			a[end + gap] = x;
		}
	}
}

選擇排序

③直接選擇排序

基本思想

每一次從待排序的數據元素中選出最小(或最大)的一個元素，存放在序列的起始(末尾)位置，直到全部待排序的數據元素排完 。

動圖演示

以每次選出最小值為例

代碼實現

void Swap(int* px, int* py)
{
	int tmp = *px;
	*px = *py;
	*py = tmp;
}
 
void SelectSort(int* a, int n)
{
	int begin = 0;
	while (begin < n - 1)
	{
		int mini = begin;
		for (int i = begin; i < n; i++)
		{
			if (a[i] < a[mini])
				mini = i;
		}
		Swap(&a[begin], &a[mini]);
		++begin;
	}
}

④堆排序

基本思想

小堆根上的元素是堆中最小的元素，大堆根上的元素是堆中最大的元素。

先將待排序列建成小(大)堆，

獲取堆根上的元素，這樣就達到瞭選出待排序列中最小(大)元素的目的，

然後再將其放至正確位置。

建堆需要註意的問題

若將待排序列建成小堆，則每次可將待排序列中最小的元素放至正確的位置，但每次排除堆根後，剩下元素組成的堆結構被打亂，需要對剩下待排序列重新建堆，反而增加的問題的復雜性。

故我們將其建成大堆，每次將堆根上的元素(待排序列中最大的元素)與待排序列中最後一個元素進行交換，將大堆根上的元素換至正確位置，然後再使用向下調整算法，將交換上來的元素調整至一個大堆中的合適位置。

圖示

代碼實現

void Swap(int* px, int* py)
{
	int tmp = *px;
	*px = *py;
	*py = tmp;
}
 
//建大堆的向下調整算法
void AdjustDown(int* a, int n, int parent)
{
	int child = parent * 2 + 1;
	while (child < n)
	{
		if (child + 1 < n && a[child + 1] > a[child])
			++child;
		if (a[child] > a[parent])
		{
			Swap(&a[child], &a[parent]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
			break;
	}
}
 
void HeapSort(int* a, int n)
{
    //先使用向下調整算法，從最後一個元素的父親開始建堆
	for (int i = (n - 1 - 1) / 2; i >= 0; --i)
	{
		AdjustDown(a, n, i);
	}
    //先交換，再調整
	for (int end = n - 1; end > 0; --end)
	{
		Swap(&a[0], &a[end]);
		AdjustDown(a, end, 0);
	}
}

交換排序

⑤冒泡排序

基本思想

從待排序列的首元素開始，從前往後依次進行比較，

若大於則交換，將其繼續與後面元素比較，直到被放至正確位置。

否則迭代至與其比較的元素，重復上面的步驟。

動圖演示

代碼實現

void Swap(int* px, int* py)
{
	int tmp = *px;
	*px = *py;
	*py = tmp;
}
 
void BubbleSort(int* a, int n)
{
	for (int j = 0; j < n; j++)
	{
		for (int i = 0; i < n - j - 1; i++)
		{
			if (a[i] > a[i + 1])
			{
				Swap(&a[i], &a[i + 1]);
			}
		}
	}
}

⑥快速排序

基本思想

任取待排序元素序列中的某元素作為基準值，按照該排序碼將待排序集合分割成兩子序列，左子序列中所有元素均小於基準值，右子序列中所有元素均大於基準值，然後最左右子序列重復該過程，直到所有元素都排列在相應位置上為止。

基本框架

void QuickSort(int* a, int left, int right)
{
	if (left >= right)
		return;
 
    //先將選定的基準值排好
	int keyi = Partion(a, left, right);
 
    //再通過遞歸排序其左右子序列
	QuickSort(a, left, keyi - 1);
	QuickSort(a, keyi + 1, right);
}

Partion函數分析

Partion函數在這裡的作用是：

將選定的基準值排到正確位置，並將待排序列分成比基準值小的左子序列，比基準值大的右子序列。

將區間按照基準值劃分為左右兩半部分的常見方式有：

1.hoare版本
基本思想：

選擇待排序列的最左值的下標為基準值所指下標，當區間左下標小於區間右下標時，先從右開始找比基準值小的值，找到後再從左開始找比基準值大的值，都找到後，將左右下標對應的值交換，然後從右開始重復上述步驟，直到左右下標相等。當左右下標相等時，將下標所指向的值與基準值互換。

動圖演示：

代碼實現：
//hoare版本
int Partion(int* a, int left, int right)
{
	int keyi = left;
	while (left < right)
	{
		//右邊先走，找小
		while (left < right && a[right] >= a[keyi])
		{
			--right;
		}
		//左邊走，找大
		while (left < right && a[left] <= a[keyi])
		{
			++left;
		}
		Swap(&a[left], &a[right]);
	}
	Swap(&a[keyi], &a[left]);
	return left;
}
2.挖坑法
基本思想：

選擇待排序列的最左值為基準值，將其下標記為坑的下標。當區間左下標小於區間右下標時，先從右開始找比基準值小的值，找到後將其放在當前坑上，並將坑替換到所找位置。再從左開始找比基準值大的值，找到後同樣將其放在當前坑上，然後從右開始重復上述步驟，直到左右下標相等。當左右下標相等時，把基準值放到當前坑所在位置。

動圖演示：

代碼實現：
//挖坑法
int Partion(int* a, int left, int right)
{
    int key = a[left];
	int pivot = left;
	while (left < right)
	{
		//右邊先走，找小
		while (left < right && a[right] >= key)
		{
			--right;
		}
		//值覆蓋，坑替換
		a[pivot] = a[right];
		pivot = right;
		//左邊走，找大
		while (left < right && a[left] <= key)
		{
			++left;
		}
		//值覆蓋，坑替換
		a[pivot] = a[left];
		pivot = left;
	}
	a[pivot] = key;
	return pivot;
}
3.前後指針法
基本思想：

選擇最左值的下標為基準值下標，並設定指向前後位置的兩個下標 cur , prev 。使 prev 指向基準值的位置，cur 指向基準值的前一個位置。當 cur <= right,也就是 cur 指向的位置小於等於右區間的位置時，從 cur 開始找比基準值小的值，並將其與 prev 所在位置的前一個交換。當 cur 跳出右區間時，將基準值與 prev 所指向的值交換。

動圖演示：

代碼實現： 
//前後指針法 ——更推薦
int Partion(int* a, int left, int right)
{
	int keyi = left;
	int cur = left + 1;
	int prev = left;
	while (cur <= right)
	{
		//cur找小，把小的換到左邊
		if (a[cur] < a[keyi])
		{
            ++prev;
			Swap(&a[cur], &a[prev]);
		}
		++cur;
	}
	Swap(&a[prev], &a[keyi]);
	return prev;
}

小結：

hoare版本與挖坑法都需要註意，不管是從右開始找還是從左開始找，始終都要註意左下標要小於右下標，若沒有此限定條件，當從任一方向開始找值時，一旦沒有找到我們所預想的值，就會導致越界情況產生。

而前後指針法是從一個方向開始，遍歷搜索一次待排序列，隻需設定一次限定條件。

故這裡更推薦使用前後指針法來實現快速排序。

Partion函數的優化

由於每次是以基準值為準，將待排序列分成左右兩個子序列，若每次能保證選到的基準值的正確位置在待排序列的中間部分，則每次分序列時，都能大致將待排序列分成均衡的兩部分，從而將排序次數減少。

這裡使用到三數取中的方法：

再排序前，先將最左值、中間值與最右值進行比較，選出三個數中的中間值，並將其與最左值交換，這樣每次以最左值為基準值時，都能選到一個大致在中間部分的數。

代碼：
//三數取中
int GetMidIndex(int* a, int left, int right)
{
	int mid = (left + right) / 2;
	if (a[left] > a[mid])
	{
		if (a[mid] > a[right])
			return mid;
		else if (a[left] < a[right])
			return left;
		else
			return right;
	}
	else
	{
		if (a[mid] < a[right])
			return mid;
		else if (a[left] > a[right])
			return left;
		else
			return right;
	}
}

快速排序代碼實現

//三數取中
int GetMidIndex(int* a, int left, int right)
{
	//int mid = (left + right) / 2;
	int mid = left + ((right - left) >> 1);
	if (a[left] > a[mid])
	{
		if (a[mid] > a[right])
			return mid;
		else if (a[left] < a[right])
			return left;
		else
			return right;
	}
	else
	{
		if (a[mid] < a[right])
			return mid;
		else if (a[left] > a[right])
			return left;
		else
			return right;
	}
}
 
void Swap(int* px, int* py)
{
	int tmp = *px;
	*px = *py;
	*py = tmp;
}
 
//前後指針法
int Partion(int* a, int left, int right)
{
	int midi = GetMidIndex(a, left, right);
	Swap(&a[midi], &a[left]);
 
	int keyi = left;
	int cur = left + 1;
	int prev = left;
	while (cur <= right)
	{
		//cur找小，把小的換到左邊
		if (a[cur] < a[keyi] && ++prev != cur)
		{
			Swap(&a[cur], &a[prev]);
		}
		++cur;
	}
	Swap(&a[prev], &a[keyi]);
	return prev;
}
 
void QuickSort(int* a, int left, int right)
{
	if (left >= right)
		return;
 
	int keyi = Partion3(a, left, right);
 
	QuickSort(a, left, keyi - 1);
	QuickSort(a, keyi + 1, right);
}

歸並排序

⑦歸並排序

基本思想

歸並排序是將待排序列先分解至單個子序列，再將已有序的子序列合並一個臨時數組中，得到完全有序的序列後再拷貝回原數組。即先使左右子序列有序，再將其歸並為一個完整的有序序列。

動圖演示

代碼實現

void _MergeSort(int* a, int left, int right, int* tmp)
{
	if (left >= right)
		return;
	int mid = left + ((right - left) >> 1);
	_MergeSort(a, left, mid, tmp);
	_MergeSort(a, mid + 1, right, tmp);
 
	//歸並
	int begin1 = left, end1 = mid;
	int begin2 = mid + 1, end2 = right;
	int i = left;
	while (begin1 <= end1 && begin2 <= end2)
	{
		if (a[begin1] <= a[begin2])
		{
			tmp[i++] = a[begin1++];
		}
		else
		{
			tmp[i++] = a[begin2++];
		}
	}
	while (begin1 <= end1)
	{
		tmp[i++] = a[begin1++];
	}
	while (begin2 <= end2)
	{
		tmp[i++] = a[begin2++];
	}
 
	//把排序後的元素拷貝回原來的數組
	for (int j = left; j <= right; ++j)
	{
		a[j] = tmp[j];
	}
}
 
void MergeSort(int* a, int n)
{
	int* tmp = (int*)malloc(sizeof(int) * n);
	if (tmp == NULL)
	{
		printf("malloc fail\n");
		exit(-1);
	}
 
	_MergeSort(a, 0, n - 1, tmp);
 
	free(tmp);
	tmp = NULL;
}

排序算法復雜度及穩定性分析

以上所述是小編給大傢介紹的七大經典排序算法圖解，希望對大傢有所幫助。在此也非常感謝大傢對WalkonNet網站的支持！

推薦閱讀：