(一)算法之七大排序-C++

最新推荐文章于 2022-04-19 11:00:22 发布
最新推荐文章于 2022-04-19 11:00:22 发布
阅读量257 收藏
点赞数 1
分类专栏： 算法 文章标签： 排序 C++ 七大排序
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mokorea/article/details/93850589
版权

目录

1.冒泡排序

2.简单选择排序

3.直接插入排序算法

4.希尔排序

5. 堆排序

6.归并排序

7.快速排序

8. 总结与算法时间复杂度分析

附录

排序：假设有n个记录的序列{r1,r2,...rn}，其相应的关键字分别为{k1,k2,...kn},需确定1，2，....,n的一种排列p1，p2,......pn,使其相应的关键字满足非递减或非递增关系，即使得序列成为一个按关键字有序的序列，这样的操作即为排序。

根据在排序过程中待排序的记录是否全部放在内存中，分为内排序和外排序。内排序主要受时间性能、辅助空间和算法复杂性实现的。

按照算法复杂度将排序分为两大类，即

       (1)简单算法：冒泡排序、简单选择排序、插入排序 ；

       (2)改进算法：希尔排序、堆排序、归并排序、快速排序  ；

1.冒泡排序

冒泡排序：一种交换排序。基本思想是，两两比较相邻记录关键字，如果反序交换，直到没有反序的记录为止。

如果待排序的序列为{2，1，3，4，5，6，7，8，9}时，如果仍遍历所有，进行比较，则作了很多无用功。因此需要改进一下，增加标记变量flag来实现算法改进。

//02冒泡排序算法
void sortMethod02(Data *list)
{
	bool flag = true;
	for (int i = 1;i <= list->length&&flag;i++)
	{
		flag = false;
		for (int  j = list->length-1; j >= i; j--)
		{
			if (list->r[j]<list->r[j-1])
			{
				swap(list, j, j - 1);
				flag = true;
			}
		}
	}
}

2.简单选择排序

简单选择排序：通过n-i次关键字间的比较，从n-i+1个记录中选出最小的关键字，并和第i(1\leq i\leq n)个记录交换之。

简单选择排序的性能上略优于冒泡排序。

//03简单选择排序算法
void sortMethod03(Data *list)
{
	int min;
	for (int  i = 1; i <= list->length; i++)
	{
		min = i;
		for (int  j = i+1; j <= list->length; j++)
		{
			if (list->r[min] > list->r[j])
			{
				min = j;
			}
		}
		if (min != i)
		{
			swap(list, i, min);
		}
	}
}

3.直接插入排序算法

直接插入排序算法：将一个数字插入到已经排好序的有序表中，从而得到一个新的，记录增加1的有序表。

直接插入排序法比冒泡和简单选择排序性能要好一些。

直接插入排序在下列两种情况比较有优势：

(1)序列本身基本有序，只需要少量的插入操作，就可以完成整个序列的排序工作；

(2)序列内数字个数比较；

//04 直接插入排序
void sortMethod04(Data *list)
{
	int j;
	for (int i = 2; i <= list->length; i++)
	{
		if (list->r[i]<list->r[i-1])
		{
			list->r[0] = list->r[i];//r[0]为哨兵位置
			for (j = i-1;list->r[j]>list->r[0]; j--)
			{
				list->r[j + 1] = list->r[j];				
			}
			list->r[j + 1] = list->r[0];
		}
	}
}

4.希尔排序

希尔排序：首先将整个序列中相距某个“增量”的记录组成多个子序列，然后在各个子序列中分别进行直接插入排序，从而得到基本有序的序列，再对整个序列进行一次直接插入排序。其特点为跳跃式移动，而非一步一步往前挪动。

针对希尔排序的说明：

(1)“增量”的选取非常关键，迄今为止，还没有找到一种最好的增量序列。但研究表明，当序列为delta[k]=2^{t-k+1}(0\leq k\leq t\leqslant [log_{2}(n+1))])时，可以获得不错的效果；“增量”数列的最后一个增量值必须等于1才行。

(2)基本有序：小的关键字基本在前面，大的基本在后面，不大不小的基本在中间。

//05 希尔排序
void sortMethod05(Data *list)
{
	int i, j;
	int delta = list->length;
	do
	{
		delta = delta / 3 + 1;
		for ( i = delta+1; i <= list->length; i++)
		{
			if (list->r[i]<list->r[i-delta])
			{
				list->r[0] = list->r[i];
				for ( j = i-delta; j>0&&list->r[0]<list->r[j]; j-=delta)
				{
					list->r[j + delta] = list->r[0];
				}
				list->r[j + delta] = list->r[0];
			}
		}

	} while (delta>1);
}

5. 堆排序

堆排序：利用堆进行排序的方法。

基本思想：将待排序的序列后成一个大顶堆。此时，整个序列最大值就是堆顶的根节点。将它移走(即与对数组的末尾元素交换，此时末尾元素就是最大值)，然后将剩余的n-1个序列重新构成一个大顶堆，这样就会得到n个元素中的次大值。如此反复执行，便得到一个有序序列。

关键步骤：(1)由无序序列构建堆。(2)在输出堆顶元素后，调整剩余元素生成一个新的堆。

特点：堆排序性能远远好过于冒泡、简单选择、直接插入的时间复杂度。

           堆排序是一种不稳定的排序方法。

           由于初始构建堆需要比较次数较多，因此，并不适合排序序列个数较少的情况。

//06 堆排序
void createHeap(Data *list, int begin, int end);
void sortMethod06(Data *list)
{
	for (int i = 1; i <= (list->length)/2; i++)
	{
		createHeap(list,i,list->length);
	}

	for (int i = list->length; i >1; i--)
	{
		swap(list, 1, i);
		createHeap(list, 1, i - 1);
	}
}
void createHeap(Data *list, int begin, int end)
{
	int temp, j;
	temp = list->r[begin];
	for ( j = 2*begin; j <= end; j*=2)
	{
		if (j < end&&list->r[j] < list->r[j + 1])
			++j;
		if (temp >= list->r[j])
			break;
		list->r[begin] = list->r[j];
		begin = j;
	}
	list->r[begin] = temp;

}

6.归并排序

归并排序：就是利用归并的思想。

2路归并排序：假设初始序列含有n个记录，则可以看成是有n个有序的子序列，每个子序列的长度为1，然后两两归并，得到[\frac{n}{2}]([x]表示不小x的最小整数)个长度为2或1的有序子序列；再两两归并，...，如此重复，直至得到一个长度为n的有序序列位置。这种排序方法为2路归并排序。

void MSort(int SR[],int TR1[],int s,int t);
void Merge(int SR[], int TR1[], int i, int m, int n);
void sortMethod07(Data *list)
{
	MSort(list->r, list->r, 1, list->length);
}

void MSort(int SR[], int TR1[], int s, int t)
{
	int m;
	int TR2[MaxSize + 1];
	if (s==t)
	{
		TR1[s] = SR[s];
	}
	else
	{
		m = (s + t) / 2;
		MSort(SR, TR2, s, m);
		MSort(SR, TR2, m+1, t);
		Merge(TR2, TR1, s, m, t);
	}
}
void Merge(int SR[], int TR[], int i, int m, int n)
{
	int j, k, l;
	for (j=m+1,k=i ; i <=m &&j<=n; k++)
	{
		if (SR[i] < SR[j])
			TR[k] = SR[i++];
		else
			TR[k] = SR[j++];
			
	}
	if (i<=m)
	{
		for ( l = 0; l <= m-i; l++)
		{
			TR[k + l] = SR[i + 1];
		}
	}
	if (j <= n)
	{
		for (l = 0; l <= n - j; l++)
		{
			TR[k + l] = SR[j + 1];
		}
	}

}

7.快速排序

快速排序：通过一趟排序将待排记录分割成独立的两部分，其中一部分记录的关键字均比另一部分记录的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序的目的。

void QSort(Data *list, int low, int high);
int Partition(Data *list, int low, int high);
void sortMethod08(Data *list)
{
	QSort(list,1,list->length);
}
void QSort(Data *list, int low, int high)
{
	int pivot;
	if (low<high)
	{
		pivot = Partition(list, low, high);

		QSort(list, low, pivot - 1);
		QSort(list, high, high);

	}
}

int Partition(Data *list, int low, int high)
{
	int pivotkey;
	pivotkey = list->r[low];
	while (low < high)
	{
		while (low<high&&list->r[high]>=pivotkey)
		{
			high--;
		}
		swap(list, low, high);
		while (low < high&&list->r[low] <= pivotkey)
			low++;
		swap(list, low, high);
	}
	return low;
}

8. 总结与算法时间复杂度分析

以上为七大排序方法，主要归属于插入排序、交换排序、选择排序和归并排序四类。

排序
插入排序类选择排序类交换排序类归并排序类

直接插入

排序

希尔排序简单选择排序堆排序冒泡排序快速排序归并排序

上述算法的时间复杂度对比

排序方式平均情况最好情况最坏情况辅助空间稳定性
冒泡排序O(n^{2})O(n)O(n^{2})O(1)稳定
简单选择排序O(n^{2})O(n^{2})O(n^{2})O(1)稳定
直接插入排序O(n^{2})O(n)O(n^{2})O(1)稳定
希尔排序O(nlogn)~O(n^{2})O(n^{1.3})O(n^{2})O(1)不稳定
堆排序O(nlogn)O(nlogn)O(nlogn)O(1)不稳定
归并排序O(nlogn)O(nlogn)O(nlogn)O(n)稳定
快速排序O(nlogn)O(nlogn)O(n^{2})O(logn)~O(n)不稳定

附录

附上所有代码：

//七大排序
#include<iostream>
using namespace std;

#define MaxSize 10 //待排序个数

struct Data
{
	int r[MaxSize + 1];//取多出的一个作为临时变量
	int length;
};

void swap(Data *list, int i, int j)
{
	int temp = list->r[i];
	list->r[i] = list->r[j];
	list->r[j] = temp;
}


//01最简单的排序
void sortMethod01(Data *list)
{
	for (int i = 1; i <= list->length; i++)
	{
		for (int j = i + 1; j <= list->length; j++)
		{
			if (list->r[i] > list->r[j])
			{
				swap(list, i, j);
			}
		}
	}
}

//02冒泡排序算法
void sortMethod02(Data *list)
{
	bool flag = true;
	for (int i = 1;i <= list->length&&flag;i++)
	{
		flag = false;
		for (int  j = list->length-1; j >= i; j--)
		{
			if (list->r[j]<list->r[j-1])
			{
				swap(list, j, j - 1);
				flag = true;
			}
		}
	}
}

//03简单选择排序算法
void sortMethod03(Data *list)
{
	int min;
	for (int  i = 1; i <= list->length; i++)
	{
		min = i;
		for (int  j = i+1; j <= list->length; j++)
		{
			if (list->r[min] > list->r[j])
			{
				min = j;
			}
		}
		if (min != i)
		{
			swap(list, i, min);
		}
	}
}

//04 直接插入排序
void sortMethod04(Data *list)
{
	int j;
	for (int i = 2; i <= list->length; i++)
	{
		if (list->r[i]<list->r[i-1])
		{
			list->r[0] = list->r[i];
			for (j = i-1;list->r[j]>list->r[0]; j--)
			{
				list->r[j + 1] = list->r[j];				
			}
			list->r[j + 1] = list->r[0];
		}
	}
}

//05 希尔排序
void sortMethod05(Data *list)
{
	int i, j;
	int delta = list->length;
	do
	{
		delta = delta / 3 + 1;
		for ( i = delta+1; i <= list->length; i++)
		{
			if (list->r[i]<list->r[i-delta])
			{
				list->r[0] = list->r[i];
				for ( j = i-delta; j>0&&list->r[0]<list->r[j]; j-=delta)
				{
					list->r[j + delta] = list->r[0];
				}
				list->r[j + delta] = list->r[0];
			}
		}

	} while (delta>1);
}

//06 堆排序
void createHeap(Data *list, int begin, int end);
void sortMethod06(Data *list)
{
	for (int i = 1; i <= (list->length)/2; i++)
	{
		createHeap(list,i,list->length);
	}

	for (int i = list->length; i >1; i--)
	{
		swap(list, 1, i);
		createHeap(list, 1, i - 1);
	}
}
void createHeap(Data *list, int begin, int end)
{
	int temp, j;
	temp = list->r[begin];
	for ( j = 2*begin; j <= end; j*=2)
	{
		if (j < end&&list->r[j] < list->r[j + 1])
			++j;
		if (temp >= list->r[j])
			break;
		list->r[begin] = list->r[j];
		begin = j;
	}
	list->r[begin] = temp;

}

//07 归并排序-递归方法
void MSort(int SR[],int TR1[],int s,int t);
void Merge(int SR[], int TR1[], int i, int m, int n);
void sortMethod07(Data *list)
{
	MSort(list->r, list->r, 1, list->length);
}

void MSort(int SR[], int TR1[], int s, int t)
{
	int m;
	int TR2[MaxSize + 1];
	if (s==t)
	{
		TR1[s] = SR[s];
	}
	else
	{
		m = (s + t) / 2;
		MSort(SR, TR2, s, m);
		MSort(SR, TR2, m+1, t);
		Merge(TR2, TR1, s, m, t);
	}
}
void Merge(int SR[], int TR[], int i, int m, int n)
{
	int j, k, l;
	for (j=m+1,k=i ; i <=m &&j<=n; k++)
	{
		if (SR[i] < SR[j])
			TR[k] = SR[i++];
		else
			TR[k] = SR[j++];
			
	}
	if (i<=m)
	{
		for ( l = 0; l <= m-i; l++)
		{
			TR[k + l] = SR[i + 1];
		}
	}
	if (j <= n)
	{
		for (l = 0; l <= n - j; l++)
		{
			TR[k + l] = SR[j + 1];
		}
	}

}

//08 快速排序
void QSort(Data *list, int low, int high);
int Partition(Data *list, int low, int high);
void sortMethod08(Data *list)
{
	QSort(list,1,list->length);
}
void QSort(Data *list, int low, int high)
{
	int pivot;
	if (low<high)
	{
		pivot = Partition(list, low, high);

		QSort(list, low, pivot - 1);
		QSort(list, high, high);

	}
}

int Partition(Data *list, int low, int high)
{
	int pivotkey;
	pivotkey = list->r[low];
	while (low < high)
	{
		while (low<high&&list->r[high]>=pivotkey)
		{
			high--;
		}
		swap(list, low, high);
		while (low < high&&list->r[low] <= pivotkey)
			low++;
		swap(list, low, high);
	}
	return low;
}


//01最简单的排序调用
void Test01(Data *list)
{
	sortMethod01(list);
	cout << "最简单的排序调用结果为：" << endl;
	for (int i = 1; i <= list->length; i++)
	{
		cout << list->r[i] << " ";
	}
	cout << endl;
}
//02冒泡排序调用
void Test02(Data *list)
{
	sortMethod02(list);
	cout << "冒泡排序调用结果为：" << endl;
	for (int i = 1; i <= list->length; i++)
	{
		cout << list->r[i] << " ";
	}
	cout << endl;
}

//03简单选择排序调用
void Test03(Data *list)
{
	sortMethod03(list);
	cout << "简单选择排序调用结果为：" << endl;
	for (int i = 1; i <= list->length; i++)
	{
		cout << list->r[i] << " ";
	}
	cout << endl;
}

//04直接插入排序调用
void Test04(Data *list)
{
	sortMethod04(list);
	cout << "简单选择排序调用结果为：" << endl;
	for (int i = 1; i <= list->length; i++)
	{
		cout << list->r[i] << " ";
	}
	cout << endl;
}

//05 希尔排序
void Test05(Data *list)
{
	sortMethod05(list);
	cout << "希尔排序调用结果为：" << endl;
	for (int i = 1; i <= list->length; i++)
	{
		cout << list->r[i] << " ";
	}
	cout << endl;
}

//06 堆排序
void Test06(Data *list)
{
	sortMethod06(list);
	cout << "堆排序调用结果为：" << endl;
	for (int i = 1; i <= list->length; i++)
	{
		cout << list->r[i] << " ";
	}
	cout << endl;
}

//07 归并排序
void Test07(Data *list)
{
	sortMethod07(list);
	cout << "归并排序调用结果为：" << endl;
	for (int i = 1; i <= list->length; i++)
	{
		cout << list->r[i] << " ";
	}
	cout << endl;
}

//08 快速排序
void Test08(Data *list)
{
	sortMethod08(list);
	cout << "快速排序调用结果为：" << endl;
	for (int i = 1; i <= list->length; i++)
	{
		cout << list->r[i] << " ";
	}
	cout << endl;
}

int main()
{
	//初始化
	Data list = 
	{ { 0,9,1,5,8,3,7,4,6,2 },
		9 
	};

	//test
	Test01(&list);
	Test02(&list);
	Test03(&list);
	Test04(&list);
	Test05(&list);
	Test06(&list);
	Test07(&list);
	Test08(&list);

	cin.get();
	system("pause");
}

 

mokorea
关注
专栏目录
【2024最新版】PCL点云处理算法汇总（C++长期更新版）
点云侠的博客
02-27 57万+
PCL学习目录。博客长期更新，最近一次更新时间为：2024年10月29日。
七大排序算法c++实现
10-03
七大排序算法C++实现，包括冒泡排序、选择排序、插入排序、希尔排序、快速排序、归并排序、堆排序。代码随机生成数组来排序，MAX1定义了数组个数，用QueryPerformanceCounterday打印除了各算法用时。
七大排序算法C++实现(代码分享)
weixin_30466039的博客
05-28 165
七大排序算法C++实现(代码分享) By qianghaohao(Xqiang) #include <iostream> #include <vector> #include <algorithm> #include <iterator> using...
c++-七大排序
Windows869的博客
03-18 733
/* 时间复杂度：最坏O(n^2) 平均O(n^2) 最好O(n) 空间复杂度：O(1) 稳定性：稳定 数据敏感：敏感 */ void insertSort(int* array, int n) { for (int i = 0; i < n - 1; ++i) { //新数据插入 //end: 有序序列的最后一个位置 int end = i; //key: 待插入的数据 int key = array[end + 1]; //找到第一个小于等于key的位置 while (end >= 0 &
七大排序算法简介与C++实现
NEUChords的博客
05-22 385
七大排序算法简介与C++实现1.冒泡排序2.选择排序3.插入排序4.希尔排序5.堆排序6.归并排序7.快速排序 1.冒泡排序 冒泡排序的基本思想：从无序序列头部开始，进行两两比较，根据大小交换位置，直到最后将最大（小）的数据元素交换到了无序队列的队尾，从而成为有序序列的一部分；下一次继续这个过程，直到所有数据元素都排好序。算法的核心在于每次通过两两比较交换位置，选出剩余无序序列里最大（小）的数据元...
数据结构之七大排序算法（C++实现）
单线程的Daniel的博客
07-14 495
数据结构之排序冒泡排序选择排序 冒泡排序 较小的数字会如同气泡一样慢慢的漂浮到上面，因此被称为冒泡排序 话不多说，见代码： /*交换两个数字*/ void mySwap(int *ori,int *des) { int temp=*ori; *ori=*des; *des=temp; } /*冒泡排序*/ void bubbleSort(vector<int> &arr,...
c++之七种经典排序算法
最新发布
02-23
本文主要探讨了七种经典的排序算法在C++中的实现、理论讲解以及复杂度分析，包括冒泡排序、选择排序、插入排序、希尔排序、堆排序、快速排序和归并排序。 1. 冒泡排序： 冒泡排序是一种简单的排序方法，通过相邻...
常用简单算法与技巧-c++版-综合文档
05-14
一、排序算法 1. 冒泡排序：通过重复遍历数组，比较相邻元素并交换位置，使最大（或最小）元素逐渐冒泡到数组的一端。 2. 选择排序：每次从未排序部分找到最小（或最大）元素，放到已排序部分的末尾。 3. 插入排序：...
七大查找算法及C++源码.pdf
09-13
本文将详细探讨七大查找算法，其中包括顺序查找和二分查找，这两种查找算法在实际应用中非常常见。 1. **顺序查找**： 顺序查找是最基础的查找算法，适用于任何存储结构的线性表，无论是顺序存储还是链式存储。它...
算法：7种排序（C++）
追梦丶
09-05 417
冒泡排序： 时间复杂度：O（n*n） 空间复杂度：O（1） 稳定性：稳定 #include&lt;stdio.h&gt; #include&lt;iostream&gt; #include&lt;cstring&gt; #include&lt;algorithm&gt; using namespace std; void Bubble_sort(int a[], int n) { for...
七大排序算法——C++版本
weixin_51547017的博客
04-19 2106
一、算法特性总结 表摘抄自文章 二、冒泡排序 1.基础版本 #include<iostream> #include<vector> #include<algorithm> using namespace std; //冒泡排序的基础版本 int main() { int num; vector<int> vec; while (cin.peek() != '\n') { cin >> num; vec.push_back(num
C++实现七大排序算法
Coast_Tt的博客
03-10 1913
七大排序方法比较： 排序方法 平均情况 最好情况 最坏情况 辅助空间 稳定性 冒泡排序 O(N2) O(N) O(N2) O(1) 稳定 选择排序 O(N2) O(N2) O(N2) O(1) 不稳定 插入排序 O(N2) O(N) O(N2) O(1) 稳定 希尔排序 O(NlogN)-O(N2) O(N1.3) O(N2) O(1) 不稳
七大排序算法及其代码实现C++
qq_40016998的博客
06-26 535
（主要为了准备面试，把排序算法再总结实现一下） 排序算法比较类排序一、交换排序1、冒泡排序2、快速排序二、插入排序1、简单插入排序2、希尔排序三、选择排序1、简单选择排序2、堆排序四、归并排序非比较类排序计数排序桶排序基数排序 比较类排序 通过比较来决定元素间的相对次序，时间复杂度不能突破O(nlogn)。 一、交换排序 1、冒泡排序 比较相邻元素，若第一个比第二个大，则交换位置。 对每一队相邻元素作相同的工作，直至当前最大元素放在当前最靠后的位置 重复1，2步骤，直至排序完成（第二小的元素被放到第二个位
[C++]七大经典排序算法详解（代码实现+解析）
cpb____的博客
03-17 7349
各种排序算法动图解析请参考 各种排序算法复杂度对比 冒泡排序法 冒泡排序是所有排序算法中相对简单且容易理解的算法，它的核心思想：通过for循环不断遍历需要排序的元素，依次比较相邻的两个元素，若不满足指定的顺序（可以从大到小排序，也可以反过来），就交换两个元素，直至完成排序。 1.比较相邻的元素。如果第一个比第二个大，就交换它们两个； 2.对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数； 3.针对所有的元素重复以上的步骤，除了最后一个； 4.重复步骤1~3，直
C++实现几大排序算法
what_lei的博客
07-03 966
问题： 输入：n个数：a1,a2,a3,...,an 输出：n个数的排列:a1',a2',a3',...,an'，使得a1' 直接排序算法： 将一个记录插入到已排序好的有序表中，从而得到一个新，记录数增1的有序表。即：先将序列的第1个记录看成是一个有序的子序列，然后从第2个记录逐个进行插入，直至整个序列有序为止。 适用范围：对于少量元素的排序。 编程思想： 直接插入排序是由两层嵌
七大排序
萌萌咚咚的博客
11-24 129
1. 插入排序 1.1 算法思想 将整个数组a分成有序和无序两部分，有序的部分为[0, i),无序为[i，a.length)。 每次取出无序中的第一个元素，将这个元素的值放到一个变量中，和有序部分中的每一个值都做比较，如果有序部分的值大于变量值，将有序的部分的这个值向后移动一个位置。 1.2 时间复杂度 最好: O(n) 最坏: O(n^2) 1.3 代码 //插入排序 public v...
排序算法总结（c++实现）
abc15766228491的博客
04-01 497
一、冒泡排序 思想：从前到后两两比较，如果前面大于后面，就交换一下，复杂度O(n^2) #include &lt;iostream&gt; using namespace std; int main() { int a[8] = {42,20,17,13,28,14,23,15}; int len = 8, temp; for (int i = 0; i &lt; ...
七大排序算法之各算法的比较
黄庆庆的世界
05-01 865
前言如果对七大排序算法还不是很了解的，可以对着下面这些链接，再去学习或者熟悉下冒泡排序选择排序插入排序快速排序堆排序归并排序希尔排序这篇文章主要是对这七大排序算法做一些总结，什么情况下应该用哪个排序算法等。正文首先，再复习一下各个排序算法的时间复杂度，以及稳定性（图源自网络）先科普一下算法的稳定性这个概念，什么叫做算法的稳定性呢？举个具体的例子首先简单的数字排序，这里稳定性没有任何意义，那么情况下...
七种常见的排序算法--c++直接上代码，注释详细
medal003的专栏
08-11 1342
七种常见的排序算法--c++直接上代码，注释详细
C++实现七大排序算法详解：从插入到希尔排序
本文档主要探讨了七种常见的排序算法的源代码实现，包括插入排序、选择排序、冒泡排序、希尔排序、快速排序、归并排序和堆排序。这些排序算法在IT领域中具有重要的应用价值，尤其是在数据处理和算法设计中。 1. **...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值