1. 插入排序

步驟：

1.從第一個元素開始，該元素可以認為已經被排序
2.取下一個元素tem，從已排序的元素序列從后往前掃描
3.如果該元素大于tem，則將該元素移到下一位
4.重復步驟3，直到找到已排序元素中小于等于tem的元素
5.tem插入到該元素的后面，如果已排序所有元素都大于tem，則將tem插入到下標為0的位置
6.重復步驟2~5

動圖演示如下：

思路：
  在待排序的元素中，假設前n-1個元素已有序，現將第n個元素插入到前面已經排好的序列中，使得前n個元素有序。按照此法對所有元素進行插入，直到整個序列有序。
  但我們并不能確定待排元素中究竟哪一部分是有序的，所以我們一開始只能認為第一個元素是有序的，依次將其后面的元素插入到這個有序序列中來，直到整個序列有序為止。

代碼如下：

void InsertSort(int* arr, int n)
{
	for (int i = 0; i < n - 1; ++i)
	{
		//記錄有序序列最后一個元素的下標
		int end = i;
		//待插入的元素
		int tem = arr[end + 1];
		//單趟排
		while (end >= 0)
		{
			//比插入的數大就向后移
			if (tem < arr[end])
			{
				arr[end + 1] = arr[end];
				end--;
			}
			//比插入的數小，跳出循環
			else
			{
				break;
			}
		}
		//tem放到比插入的數小的數的后面
		arr[end  + 1] = tem;
		//代碼執行到此位置有兩種情況:
		//1.待插入元素找到應插入位置（break跳出循環到此）
		//2.待插入元素比當前有序序列中的所有元素都小（while循環結束后到此）
	}
}

時間復雜度：最壞情況下為O(N*N)，此時待排序列為逆序，或者說接近逆序
      最好情況下為O(N)，此時待排序列為升序，或者說接近升序。
空間復雜度：O(1)

2.希爾排序

步驟：

1.先選定一個小于N的整數gap作為第一增量，然后將所有距離為gap的元素分在同一組，并對每一組的元素進行直接插入排序。然后再取一個比第一增量小的整數作為第二增量，重復上述操作…
2.當增量的大小減到1時，就相當于整個序列被分到一組，進行一次直接插入排序，排序完成。
動圖如下：

思路：
希爾排序，先將待排序列進行預排序，使待排序列接近有序，然后再對該序列進行一次插入排序，此時插入排序的時間復雜度為O(N)，

代碼如下：

//希爾排序
void ShellSort(int* arr, int n)
{
	int gap = n;
	while (gap>1)
	{
		//每次對gap折半操作
		gap = gap / 2;
		//單趟排序
		for (int i = 0; i < n - gap; ++i)
		{
			int end = i;
			int tem = arr[end + gap];
			while (end >= 0)
			{
				if (tem < arr[end])
				{
					arr[end + gap] = arr[end];
					end -= gap;
				}
				else
				{
					break;
				}
			}
			arr[end + gap] = tem;
		}
	}
}

時間復雜度平均：O(N^1.3)
空間復雜度：O(1)

3.選擇排序

思路：
每次從待排序列中選出一個最小值，然后放在序列的起始位置，直到全部待排數據排完即可。
實際上，我們可以一趟選出兩個值，一個最大值一個最小值，然后將其放在序列開頭和末尾，這樣可以使選擇排序的效率快一倍。

動圖如下：

代碼如下：

//選擇排序
void swap(int* a, int* b)
{
	int tem = *a;
	*a = *b;
	*b = tem;
}
void SelectSort(int* arr, int n)
{
	//保存參與單趟排序的第一個數和最后一個數的下標
	int begin = 0, end = n - 1;
	while (begin < end)
	{
		//保存最大值的下標
		int maxi = begin;
		//保存最小值的下標
		int mini = begin;
		//找出最大值和最小值的下標
		for (int i = begin; i <= end; ++i)
		{
			if (arr[i] < arr[mini])
			{
				mini = i;
			}
			if (arr[i] > arr[maxi])
			{
				maxi = i;
			}
		}
		//最小值放在序列開頭
		swap(&arr[mini], &arr[begin]);
		//防止最大的數在begin位置被換走
		if (begin == maxi)
		{
			maxi = mini;
		}
		//最大值放在序列結尾
		swap(&arr[maxi], &arr[end]);
		++begin;
		--end;
	}
}

時間復雜度：最壞情況：O(N^2)
      最好情況：O(N^2)
空間復雜度：O(1)

4.冒泡排序

思路：
左邊大于右邊交換一趟排下來最大的在右邊

動圖如下：

代碼如下：

//冒泡排序
void BubbleSort(int* arr, int n)
{
	int end = n;
	while (end)
	{
		int flag = 0;
		for (int i = 1; i < end; ++i)
		{
			if (arr[i - 1] > arr[i])
			{
				int tem = arr[i];
				arr[i] = arr[i - 1];
				arr[i - 1] = tem;
				flag = 1;
			}
		}
		if (flag == 0)
		{
			break;
		}
		--end;
	}
}

時間復雜度：最壞情況：O(N^2)
      最好情況：O(N)
空間復雜度：O(1)

5.堆排序

堆排可看之間這篇博文----->[堆排]

6.快速排序

6.1 hoare版本(左右指針法)

思路：
1、選出一個key，一般是最左邊或是最右邊的。
2、定義一個begin和一個end，begin從左向右走，end從右向左走。（需要注意的是：若選擇最左邊的數據作為key，則需要end先走；若選擇最右邊的數據作為key，則需要bengin先走）。
3、在走的過程中，若end遇到小于key的數，則停下，begin開始走，直到begin遇到一個大于key的數時，將begin和right的內容交換，end再次開始走，如此進行下去，直到begin和end最終相遇，此時將相遇點的內容與key交換即可。（選取最左邊的值作為key）
4.此時key的左邊都是小于key的數，key的右邊都是大于key的數
5.將key的左序列和右序列再次進行這種單趟排序，如此反復操作下去，直到左右序列只有一個數據，或是左右序列不存在時，便停止操作，此時此部分已有序

單趟動圖如下：

代碼如下：

//快速排序   hoare版本(左右指針法)
void QuickSort(int* arr, int begin, int end)
{
	//只有一個數或區間不存在
	if (begin >= end)
		return;
	int left = begin;
	int right = end;
	//選左邊為key
	int keyi = begin;
	while (begin < end)
	{
		//右邊選小   等號防止和key值相等    防止順序begin和end越界
		while (arr[end] >= arr[keyi] && begin < end)
		{
			--end;
		}
		//左邊選大
		while (arr[begin] <= arr[keyi] && begin < end)
		{
			++begin;
		}
		//小的換到右邊，大的換到左邊
		swap(&arr[begin], &arr[end]);
	}
	swap(&arr[keyi], &arr[end]);
	keyi = end;
	//[left,keyi-1]keyi[keyi+1,right]
	QuickSort(arr, left, keyi - 1);
	QuickSort(arr,keyi + 1,right);
}

時間復雜度:

快速排序的過程類似于二叉樹其高度為logN，每層約有N個數，如下圖所示：

6.2 挖坑法

思路：
挖坑法思路與hoare版本(左右指針法)思路類似
1.選出一個數據（一般是最左邊或是最右邊的）存放在key變量中，在該數據位置形成一個坑
2、還是定義一個L和一個R，L從左向右走，R從右向左走。（若在最左邊挖坑，則需要R先走；若在最右邊挖坑，則需要L先走）

后面的思路與hoare版本(左右指針法)思路類似在此處就不說了

單趟動圖如下：

代碼如下：

//快速排序法  挖坑法
void QuickSort1(int* arr, int begin, int end)
{
	if (begin >= end)
		return;
	int left = begin,right = end;
	int key = arr[begin];
	while (begin < end)
	{
		//找小
		while (arr[end] >= key && begin < end)
		{
			--end;
		}
		//小的放到左邊的坑里
		arr[begin] = arr[end];
		//找大
		while (arr[begin] <= key && begin < end)
		{
			++begin;
		}
		//大的放到右邊的坑里
		arr[end] = arr[begin];
	}
	arr[begin] = key;
	int keyi = begin;
	//[left,keyi-1]keyi[keyi+1,right]
	QuickSort1(arr, left, keyi - 1);
	QuickSort1(arr, keyi + 1, right);
}

6.3 前后指針法

思路：
1、選出一個key，一般是最左邊或是最右邊的。
2、起始時，prev指針指向序列開頭，cur指針指向prev+1。
3、若cur指向的內容小于key，則prev先向后移動一位，然后交換prev和cur指針指向的內容，然后cur指針++；若cur指向的內容大于key，則cur指針直接++。如此進行下去，直到cur到達end位置，此時將key和++prev指針指向的內容交換即可。

經過一次單趟排序，最終也能使得key左邊的數據全部都小于key，key右邊的數據全部都大于key。

然后也還是將key的左序列和右序列再次進行這種單趟排序，如此反復操作下去，直到左右序列只有一個數據，或是左右序列不存在時，便停止操作

//快速排序法  前后指針版本
void QuickSort2(int* arr, int begin, int end)
{
	if (begin >= end)
		return;
	int cur = begin, prev = begin - 1;
	int keyi = end;
	while (cur != keyi)
	{
		if (arr[cur] < arr[keyi] && ++prev != cur)
		{
			swap(&arr[cur], &arr[prev]);
		}
		++cur;
	}
	swap(&arr[++prev],&arr[keyi]);
	keyi = prev;
	//[begin,keyi -1]keyi[keyi+1,end]
	QuickSort2(arr, begin, keyi - 1);
	QuickSort2(arr, keyi + 1, end);

}

以上就是快速學習六大排序算法的詳細內容，更多關于六大排序算法的資料請關注服務器之家其它相關文章！

原文鏈接：https://blog.csdn.net/weixin_50886514/article/details/119045154