排序算法详解与实现-优快云博客

本文详细介绍了多种排序算法，包括直接插入排序、希尔排序、选择排序、堆排序、冒泡排序、快速排序、归并排序和非比较排序，如计数排序、基数排序。讨论了各种排序算法的时间复杂度、空间复杂度以及稳定性，并提供了相应的代码实现。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

1、插入排序：

基本思想：直接插入排序是一种简单的插入排序法，其基本思想是：把待排序的记录按其关键码值的大小逐个插入到一个已经排好序的有序序列中，直到所有的记录插入完为止，得到一个新的有序序列。
直接插入排序：
当插入第i（i>=1）个元素时，前面的array[0],array[1],…,array[i-1]已经排好序，此时用array[i]的排序码与array[i-1],array[i-2],…的排序码顺序进行比较，找到插入位置即将array[i]插入，原来位置上的元素顺序后移。

直接插入排序的特性总结：

元素集合越接近有序，直接插入排序算法的时间效率越高
时间复杂度：O(N^2)
空间复杂度：O（1），它是一种稳定的排序算法
稳定性：稳定
适用场景：数据有序或接近有序（注意：有序或接近有序与用户所需要序列一致），数据量少，搬移元素个数比较少
直接插入排序代码：

//插入排序	
void InsertSort(int array[], int size)
{
	for (int i = 1; i < size; ++i)
	{
		int key = array[i];//要插入的数
		int end = i - 1;
		//在有序区间[0,1)中向前遍历，如果要插入的数小于有序数组中最后一个数，交换两个数，继续比较
		while (key < array[end] && end >= 0)
		{
			array[end + 1] = array[end];
			end--;
		}
		array[end + 1] = key;//新的要插入的值，有序数组最后一个数得下一个数
	}
	
}

2、希尔排序（缩小增量排序）
希尔排序又称缩小增量法。希尔排序的基本思想是：先选定一个整数，把待排序文件中所有记录分成个组，所有距离为的记录分在同一组内，并对每一组内的记录进行排序。然后取，重复上述分组和排序的工作。当到达=1时，所有记录在统一组内排好序。
在这里插入图片描述

希尔排序的特性总结：

希尔排序是对直接插入排序的优化。
当gap > 1时都是预排序，目的是让数组更接近于有序。当gap == 1时，数组已经接近有序的了，这样就会很快。这样整体而言，可以达到优化的效果。我们实现后可以进行性能测试的对比。
希尔排序的时间复杂度不好计算，需要进行推导，推导出来平均时间
复杂度：O(N^1.3 —N^2）
稳定性：不稳定

希尔排序代码：

//希尔排序
void ShellSort(int* array, int size)
{
	int gap = size;
	while (gap > 1)
	{
		gap = gap / 3 + 1;//gap=gap/2;
		for (int i = gap; i < size; i++)
		{
			int key = array[i];
			int end = i - gap;

			while (key < array[end] && end >= 0)
			{
				array[end + gap] = array[end];
				end -= gap;
			}
			array[end + gap] = key;
		}
	}
}

3、选择排序：

基本思想：每次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完。
直接选择排序：
1）在元素集合array[i]–array[n-1]中选择关键码最大(小)的数据元素
2）若它不是这组元素中的最后一个(第一个)元素，则将它与这组元素中的最后一个（第一个）元素交换
3）在剩余的array[i]–array[n-2]（array[i+1]–array[n-1]）集合中，重复上述步骤，直到集合剩余1个元素

直接选择排序的特性总结：

直接选择排序思考非常好理解，但是效率不是很好。实际中很少使用
时间复杂度：O(N^2)
空间复杂度：O(1)
. 稳定性：不稳定

选择排序的代码：

 //选择排序
void SelectSort(int* array, int size)
{
	int begin = 0, end = size - 1;
	//无序区间是[left,right]
	//无序区间内只剩1个数或者没有数
	while (begin < end)
	{
		//无序区间内最大最小
		int minPos = begin;
		int maxPos = begin;
		int index = begin + 1;
		while (index <= end)
		{
			if (array[index] > array[maxPos])
				maxPos = index;
			if (array[index] < array[minPos])
				minPos = index;

			++index;
		}

		//注意：最右侧位置可能存储得是当前最小值
		if (maxPos != end)
		{
			Swap(&array[maxPos], &array[end]);//最大的数和最后一个数交换
		}
		//如果最右侧的位置可能存储得是当前的最小值，经过上述交换之后,最小值的位置已经发生改变
		//必须要更新minPos
		if (minPos == end)
		{
			minPos = maxPos;
		}
		if (minPos != begin)
		{
			Swap(&array[minPos], &array[begin]);//等于（a+min，a+left）最小的数和无序区间的第一个数交换
		}
		++begin;
		--end;
	}
}
void SelectSort(int* array, int size)
{
	for (int i = 0; i < size - 1; i++)
	{
		int maxPos = 0;
		for (int j = 1; j < size - i; ++j)
		{
			if (array[j] > array[maxPos])
			{
				maxPos = j;
			}
		}
		if (maxPos != size - 1 - i)
		{
			Swap(&array[maxPos], &array[size - i - 1]);
		}
	}
}

4、堆排序
堆排序(Heapsort)是指利用堆积树（堆）这种数据结构所设计的一种排序算法，它是选择排序的一种。它是通过堆来进行选择数据。需要注意的是排升序要建大堆，排降序建小堆。

基本思想：
堆排序可以按照以下步骤来完成：
1、首先将序列构建称为大顶堆；（这样满足了大顶堆那条性质：位于根节点的元素一定是当前序列的最大值）

2、取出当前大顶堆的根节点，将其与序列末尾元素进行交换；（此时：序列末尾的元素为已排序的最大值；由于交换了元素，当前位于根节点的堆并不一定满足大顶堆的性质）
3、对交换后的n-1个序列元素进行调整，使其满足大顶堆的性质；
4、重复2.3步骤，直至堆中只有1个元素为止

直接选择排序的特性总结：

堆排序使用堆来选数，效率就高了很多。
时间复杂度：O(N*logN)
空间复杂度：O(1)
稳定性：不稳定

堆排序代码：

  //堆排序
   void HeapAdjust(int* array, int size, int parent)
{
	int child = parent * 2 + 1;
	while (child<size)
	{
		//如果右子树的值大于左子树的值，则最大的数为右子树
		if (child + 1 < size && array[child + 1] > array[child])
			child += 1;

		if (array[child] > array[parent])
		{
			Swap(&array[parent], &array[child]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
			return;
	}
}
void HeapSort(int* array, int size)
{
	int end = size - 1;
	//1、建堆
	//找到倒数第一个非叶子节点
	for(int root = ((size - 2) >> 1); root >= 0; --root)
	{
		HeapAdjust(array, size, root);
	}
	//2、利用堆删除的思想来进行排序
	while (end)
	{
		Swap(&array[0], &array[end]);//堆顶元素和无序区间的最后一个数交换
		HeapAdjust(array, end, 0);
		end--;
	}
}

5、交换排序：

基本思想：所谓交换，就是根据序列中两个记录键值的比较结果来对换这两个记录在序列中的位置，交换排序的特点是：将键值较大的记录向序列的尾部移动，键值较小的记录向序列的前部移动。
冒泡排序
冒泡排序思路比较简单：
1）将序列当中的左右元素，依次比较，保证右边的元素始终大于左边的元素；（第一轮结束后，序列最后一个元素一定是当前序列的最大值；）
2)对序列当中剩下的n-1个元素再次执行步骤1。
3)对于长度为n的序列，一共需要执行n-1轮比较（利用while循环可以减少执行次数）

冒泡排序的特性总结：

冒泡排序是一种非常容易理解的排序
时间复杂度：O(N^2)
空间复杂度：O(1)
稳定性：稳定

冒泡排序代码：

  //冒泡排序
   void BubbleSort(int* array, int size)
{
	//外层循环控制的是冒泡排序的趟数，既需要冒泡多少次
	for (int i = 0; i < size-1; ++i)
	{
		int isChange = 0;
		//具体冒泡的方式：依次用相邻两个元素进行比较，将大的元素往后翻
		//j:表示数组的下标--->j表示后一个元素的标志
		for (int j = 1; j < size - i; ++j)
		{
			if (array[j-1] > array[j])
			{
				Swap(&array[j - 1], &array[j]);
				isChange = 1;
			}
		}
		//如果没有被修改，说明有序
		if (!isChange)
		{
			return;
		}
	}
}

6、快速排序
概念：快速排序是Hoare于1962年提出的一种二叉树结构的交换排序方法，其基本思想为：任取待排序元素序列中的某元素作为基准值，按照该排序码将待排序集合分割成两子序列，左子序列中所有元素均小于基准值，右子序列中所有元素均大于基准值，然后最左右子序列重复该过程，直到所有元素都排列在相应位置上为止。
将区间按照基准值划分为左右两半部分的常见方式有：

    1. hoare版本 2. 挖坑法 3. 前后指针版本

基本思想 ：
1、在待排序区间[left,right]中选择一个基准值(pivot)
2、扫描整个待排序区间，将比基准值小的放在基准值的左面，比基准值大的放在基准值右边。（分组----->基准值最终所在的下标[pivotIndex]）
3、整个待排序区间被分为三部分：
比基准值小的[left,pivotIndex]；
基准值[pivotIndex];
比基准值大的[pivotIndex+1,right]；
4、按照同样方式处理左右两个小区间，直到小区间内数据为1个或0个
在这里插入图片描述

快速排序的特性总结：

快速排序整体的综合性能和使用场景都是比较好的，所以才敢叫快速排序
时间复杂度：O(N*logN)

最坏：O(N^2)，时间复杂度看最坏情况，为什么时间复杂度是O(NlogN）？
原因：
1、并不是所有的划分都集中在区间最右侧
2、快拍不适合数据接近有序的场景—适合数据随机的场景
3、尽量避免每次划分数据集中在基准值一侧的场景—>优化快排，取基准值，不要单纯的只从区间最左侧或者最右侧取值，以三个位置数据最中间的数据作为基准值
4、快排取得是平均时间复杂度—>O(NlogN)

空间复杂度：O(logN)

如果递归的层次过深，而每次递归都需要分配栈空间，栈空间又是有大小，因此递归过深，可能会导致栈溢出
优化：越往下每个分组中的数据越少，没有必要递归到区间中只剩下一个数据的那一次，设置一个阈值，如果区间中的数据小于阈值，可以采用插入排序优化。
问题：数据数据量过大，还没有到达所设置的阈值，对已经导致栈溢出，怎么解决？
解决方式：将快速排序写成循环的

稳定性：不稳定

快速排序代码：

//找基准值
int GetIndexOfmid(int* array, int left, int right)
{
	int mid = left + ((right - left) >> 1);
	if (array[left] < array[right - 1])
	{
		if (array[mid] < array[left])
			return left;
		else if (array[mid] > array[right - 1])
			return right - 1;
		else
			return mid;
	}
	else
	{
		if (array[mid] > array[left])
			return left;
		else if (array[mid] < array[right - 1])
			return right - 1;
		else
			return mid;
	}
}

//hoare版本
int Partion1(int* array, int left, int right)
{
	int begin = left;
	int end = right - 1;
	int key;
	int mid = GetIndexOfmid(array, left, right);
	Swap(&array[mid], &array[right - 1]);
	key = array[end];

	while (begin < end)
	{
		//让begin从前往后找，找比基准直大的元素，找到之后停止
		while (begin < end && array[begin] <= key)
			begin++;
		//让end从前往前找，找比基准直小的元素，找到之后停止
		while (begin < end && array[end] >= key)
			end--;
		if (begin < end)
		{
			Swap(&array[begin], &array[end]);
		}
	}
	if (begin != right - 1)
		Swap(&array[begin], &array[right - 1]);

	return begin;
}
//挖坑法

int Partion2(int* array, int left, int right)
{
	int begin = left;
	int end = right - 1;
	int key;
	int mid = GetIndexOfmid(array, left, right);
	Swap(&array[mid], &array[right - 1]);
	key = array[end];

	while (begin<end)
	{
		//让begin从前往后找，找比基准直大的元素，找到之后停止
		while (begin < end && array[begin] <= key)
			begin++;
		//让begin位置的元素填end位置的坑
		if (begin < end)
		{
			array[end--] = array[begin];
		}

		//现在begin位置形成一个新的坑
		//让end从前往前找，找比基准直小的元素，找到之后停止
		while (begin < end && array[end] >= key)
			end--;

		//end找到了一个比基准值小的元素
		//让end位置的元素填begin位置的坑
		if (begin < end)
		{
			array[begin++] = array[end];
		}
	}
	//用基准值填最后的坑
	array[begin] = key;
	return begin;
}
//前后指针版本
int Partion3(int* array, int left, int right)
{
	int cur = left;
	int prev = cur - 1;
	int key;
	int mid = GetIndexOfmid(array, left, right);
	Swap(&array[mid], &array[right - 1]);
	key = array[right-1];

	while (cur < right)
	{
		if (array[cur] < key && ++prev != cur)
		{
			Swap(&array[prev], &array[cur]);
		}
		++cur;
	}
	if (++prev != right - 1)
		Swap(&array[prev], &array[right - 1]);

	return prev;
}

void QuickSort(int* array, int left, int right)
{
	if (right - left < 16)
	{
		InsertSort(array + left, right - left);
	}
	else
	{
		int div = Partion1(array, left, right);
		QuickSort(array, left, div);
		QuickSort(array, div + 1, right);
	}
}
void QuickSort(int* a, int size)
{
	QuickSort(a, 0, size);
}

//循环版本：
void QuickSortNor(int* array, int size)
{
	std::stack<int> s;
	//将数据整体插入
	s.push(size);
	s.push(0);

	int left = 0, right = 0;
	while (!s.empty())
	{
		left = s.top();
		s.pop();
		right = s.top();
		s.pop();

		if (right - left > 1)
		{
			int div = Partion2(array, left, right);

			//div是基准值的位置
			//基准值的左侧：[left，div)
			//基准值的右侧：[div+1,right)

			s.push(right);
			s.push(div + 1);

			s.push(div);
			s.push(left);
		}
	}
}

7、归并排序

**基本思想：**归并排序（MERGE-SORT）是建立在归并操作上的一种有效的排序算法,该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。
归并排序其实要做两件事：
1）分解----将序列每次折半拆分
2）合并----将划分后的序列段两两排序合并
因此，归并排序实际上就是两个操作，拆分+合并

在这里插入图片描述

归并排序的特性总结：

归并的缺点在于需要O(N)的空间复杂度，归并排序的思考更多的是解决在磁盘中的外排序问题。
时间复杂度：O(N*logN)
空间复杂度：O(N)
稳定性：稳定

场景：对10G的元素进行排序
1、将文件逻辑划分为每512M一份
2、对划分好的逻辑文件先每个文件的内存中进行排序
3、对0~19的20个逻辑文件进行两两归并
4、具体归并方式：
a、读取0号文件的前256M的数据，读取1号文件中前256M的数据
b、对两个256M的元素进行归并
c、那个区间中的元素先搬移完，继续读取该分组剩余数据读取到内存中继续和剩余数据进行归并

归并排序代码：

void MergeData(int* array, int left, int mid, int right, int* temp)
{
	int begin1 = left, end1 = mid;
	int begin2 = mid, end2 = right;
	int index = left;
	while (begin1 < end1 && begin2 < end2)
	{
		if (array[begin1] <= array[begin2])
			temp[index++] = array[begin1++];
		else
			temp[index++] = array[begin2++];
	}
	while (begin1 < end1)
		temp[index++] = array[begin1++];
	while (begin2 < end2)
		temp[index++] = array[begin2++];
}
void MergeSort(int* array, int left, int right, int* temp)
{
	//只有一个元素
	if (right - left > 1)
	{
		//先找中间位置
		int mid = (left + ((right - left) >> 1));
		//[0,mid)[mid,size)
		MergeSort(array, left, mid, temp);
		MergeSort(array, mid, right, temp);
		MergeData(array, left, mid, right, temp);//归并
		memcpy(array + left, temp + left, (right - left) * sizeof(array[0]));
	}
	
}

void MergeSort(int* array, int size)
{
	int* temp = (int*)malloc(sizeof(array[0]) * size);
	if (temp == NULL)
	{
		assert(0);
		return;
	}
	MergeSort(array, 0, size, temp);
	free(temp);
}

//循环方式的归并排序
void MergeSortNor(int* array, int size)
{
	int gap = 1;
	int* temp = (int*)malloc(sizeof(array[0]) * size);
	if (temp == NULL)
	{
		assert(0);
		return;
	}
	while (gap < size)
	{
		for (int i = 0; i < size; i += 2 * gap)
		{
			int left = i;
			int mid = left + gap;
			int right = mid + gap;

			//随着gap的变化，mid和right可能会越界
			if (mid > size)
				mid = size;
			if (right > size)
				right = size;
			MergeData(array, left, mid, right, temp);
		}
		memcpy(array, temp, size*sizeof(array[0]));
		gap <<= 1;
	}
	free(temp);
}

8、非比较排序

基本思想：计数排序又称为鸽巢原理，是对哈希直接定址法的变形应用。操作步骤：
1）统计相同元素出现次数
2）根据统计的结果将序列回收到原来的序列中

在这里插入图片描述

计数排序的特性总结：
1）. 计数排序在数据范围集中时，效率很高，但是适用范围及场景有限。
2）. 时间复杂度：O(MAX(N,范围))
3）. 空间复杂度：O(范围)
4）. 稳定性：稳定

计数排序代码：

void CountSort(int*  array, int size)
{
	//1、统计数据的范围，并不是必须的（如果用户告诉数据范围，就不需要来统计范围）
	int min = array[0];
	int max = array[0];
	for (int i = 1; i < size; ++i)
	{
		if (array[i] < min)
			min = array[i];
		if (array[i] > max)
			max = array[i];
	}
	//2、申请计数空间
	int range = max - min + 1;
	int* arraycount = (int*)malloc(range * sizeof(int));
	if (NULL == range)
	{
		assert(0);
		return;
	}
	memset(arraycount, 0, range * sizeof(int));
	//3、统计每个元素出现的次数
	for (int i = 0; i < size; ++i)
	{
		arraycount[array[i] - min]++;
	}
	//4、对数据进行回收
	int index = 0;
	for (int i = 0; i < range; ++i)
	{
		while (arraycount[i]--)
		{
			array[index++] = i + min;
		}
	}
	free(arraycount);
}

9、基数排序

基本思想：
将所有待比较数值（正整数）统一为同样的数位长度，数位较短的数前面补零。然后，从最低位开始，依次进行一次排序。这样从最低位排序一直到最高位排序完成以后,数列就变成一个有序序列。
算法步骤：
1、将所有待比较数值（正整数）统一为同样的数位长度，数位较短的数前面补零。
2、从最低位开始，依次进行一次排序。
3、这样从最低位排序一直到最高位排序完成以后, 数列就变成一个有序序列。
基数排序的方式可以采用 LSD（Least significant digital）或 MSD（Most significant digital），LSD 的排序方式由键值的最右边开始，而 MSD 则相反，由键值的最左边开始。
基数排序的特性总结：
1）. 时间复杂度：O(MN)M:最大数据的位数 N：数据总数
2）. 空间复杂度：O(N)
3）. 稳定性：稳定

常见排序算法的实现