插入排序

①直接插入排序

基本思想

動圖演示

代碼實作

②希爾排序

基本思想

圖示

代碼實作

選擇排序

③直接選擇排序

基本思想

動圖演示

代碼實作

④堆排序

基本思想

建堆需要注意的問題

圖示

代碼實作

交換排序

⑤冒泡排序

基本思想

動圖演示

代碼實作

⑥快速排序

基本思想

基本框架

Partion函式分析

Partion函式的優化

快速排序代碼實作

歸并排序

⑦歸并排序

基本思想

動圖演示

代碼實作

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

插入排序

①直接插入排序

基本思想

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

若有序序列中的元素大于待排元素，則將較大的元素往后覆寫；

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

動圖演示

代碼實作

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;
}

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

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/374742.html

標籤：java

上一篇：僅用5個執行緒，讓Idea全系列Ide能看電視、直播、電影、聽廣播、音樂、美女圖

下一篇：大二期末作孽（SpringBoot+Vue前后端分離博客社區（重構White Hole））

【資料結構】圖解七大排序

插入排序

①直接插入排序

基本思想

動圖演示

代碼實作

②希爾排序

基本思想

圖示

代碼實作

選擇排序

③直接選擇排序

基本思想

動圖演示

代碼實作

④堆排序

基本思想

建堆需要注意的問題

圖示

代碼實作

交換排序

⑤冒泡排序

基本思想

動圖演示

代碼實作

⑥快速排序

基本思想

基本框架

Partion函式分析

Partion函式的優化

快速排序代碼實作

歸并排序

⑦歸并排序

基本思想

動圖演示

代碼實作

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