十大排序算法

最新推荐文章于 2023-03-04 15:34:50 发布
最新推荐文章于 2023-03-04 15:34:50 发布
阅读量403 收藏 2
点赞数 3
分类专栏： 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43554997/article/details/90733451
版权

目录

1.直接插入排序

 2.折半插入排序

3.希尔排序

 4.冒泡排序

5.快速排序

6.简单选择排序

7.堆排序

8.二路归并排序

9.基数排序

10.桶排序

 

存储结构

typedef int KeyType;	//定义关键字类型为int
typedef char InfoType;

typedef struct
{	KeyType key;		//关键字项
	InfoType data;		//其他数据项，类型为InfoType
} RecType;				//查找元素的类型

1.直接插入排序

插入排序（Insertion-Sort）的算法描述是一种简单直观的排序算法。它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。

3.1 算法描述

一般来说，插入排序都采用in-place在数组上实现。具体算法描述如下：

  • 从第一个元素开始，该元素可以认为已经被排序；
  • 取出下一个元素，在已经排序的元素序列中从后向前扫描；
  • 如果该元素（已排序）大于新元素，将该元素移到下一位置；
  • 重复步骤3，直到找到已排序的元素小于或者等于新元素的位置；
  • 将新元素插入到该位置后；
  • 重复步骤2~5。

3.2 动图演示

void InsertSort(RecType R[], int n) //对R[0..n-1]按递增有序进行直接插入排序
{
	int i, j; RecType tmp;
	for (i = 1; i < n; i++)
	{
	  if (R[i].key < R[i - 1].key)	//反序时 
		{
		  tmp = R[i];
		  j = i - 1;
		  do					//找R[i]的插入位置 
			{
				R[j + 1] = R[j];   	//将关键字大于R[i].key的记录后移
				j--;
			} while (j >= 0 && R[j].key > tmp.key);
			R[j + 1] = tmp;      		//在j+1处插入R[i]
		}
	
	}
}

 

 

 2.折半插入排序

 

void BinInsertSort(RecType R[],int n)
{	int i, j, low, high, mid;
	RecType tmp;
	for (i=1;i<n;i++) 
	{
		if (R[i].key<R[i-1].key)		//反序时 
		{
			tmp=R[i];		  			//将R[i]保存到tmp中
	     	low=0;  high=i-1;
			while (low<=high)	  		//在R[low..high]中查找插入的位置
			{
				mid=(low+high)/2;		//取中间位置
				if (tmp.key<R[mid].key)
					high=mid-1;			//插入点在左半区
				else 
					low=mid+1;			//插入点在右半区
			}                          	//找位置high
			for (j=i-1;j>=high+1;j--)	//集中进行元素后移
				R[j+1]=R[j];
			R[high+1]=tmp;				//插入tmp 
		}
	} 
}

 

 

 

 

 

 

3.希尔排序

1959年Shell发明，第一个突破O（n 2）的排序算法，是简单插入排序的改进版。它与插入排序的不同之处在于，它会优先比较距离较远的元素。希尔排序又叫缩小增量排序。

算法描述

先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序，具体算法描述：

  • 选择一个增量序列T1，T2，...，TK，其中TI> TJ，TK = 1;
  • 按增量序列个数k，对序列进行k趟排序;
  • 每趟排序，根据对应的增量ti，将待排序列分割成若干长度为m的子序列，分别对各子表进行直接插入排序。仅增量因子为1时，整个序列作为一个表来处理，表长度即为整个序列的长度。

动图演示

void ShellSort(RecType R[], int n) //希尔排序算法
{
  int i, j, d;
  RecType tmp;
  d = n / 2;					//增量置初值
  while (d > 0)
  {
	for (i = d; i < n; i++) 	//对所有组采用直接插入排序
	{
	  tmp = R[i];		//对相隔d个位置一组采用直接插入排序
	  j = i - d;
	  while (j >= 0 && tmp.key < R[j].key)
	  {
		R[j + d] = R[j];
		j = j - d;
	  }
	  R[j + d] = tmp;
	 }
	d = d / 2;				//减小增量
  }
}

 

 

 

 4.冒泡排序

冒泡排序是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。 

算法描述

  • 比较相邻的元素如果第一个比第二个大，就交换它们两个。
  • 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数;
  • 针对所有的元素重复以上的步骤，除了最后一个;
  • 重复步骤1〜3，直到排序完成。

动图演示

void BubbleSort(RecType R[],int n)
{
	int i,j,k;
	RecType tmp;
	for (i=0;i<n-1;i++) 
	{
		for (j=n-1;j>i;j--)	//比较,找出本趟最小关键字的记录
			if (R[j].key<R[j-1].key)   
			{
				tmp=R[j];  //R[j]与R[j-1]进行交换,将最小关键字记录前移
				R[j]=R[j-1];
				R[j-1]=tmp;
			}
	}
} 


//改进的冒泡排序算法
void BubbleSort1(RecType R[],int n)
{	int i,j;
	bool exchange;
	RecType tmp;
	for (i=0;i<n-1;i++) 
	{	exchange=false;					//一趟前exchange置为假
		for (j=n-1;j>i;j--)				//归位R[i],循环n-i-1次
			if (R[j].key<R[j-1].key)	//相邻两个元素反序时
			{	tmp=R[j];				//将这两个元素交换
				R[j]=R[j-1];
				R[j-1]=tmp;
				exchange=true;			//一旦有交换，exchange置为真
			}
	
		if (!exchange)					//本趟没有发生交换，中途结束算法
			return;
	}
}

 

5.快速排序

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

算法描述

快速排序使用分治法来把一个串（名单）分为两个子串（子列表）具体算法描述如下：

动图演示

  • 从数列中挑出一个元素，称为“基准”（pivot）;
  • 重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置这个称为分区（分区）操作。 
  • 递归地（递归）把小于基准值元素的子数列和大于基准值元素的子数列排序。
int partition(RecType R[],int s,int t)	//一趟划分
{
	int i=s,j=t;
	RecType tmp=R[i];			//以R[i]为基准
	while (i<j)  				//从两端交替向中间扫描,直至i=j为止
	{	while (j>i && R[j].key>=tmp.key)
			j--;				//从右向左扫描,找一个小于tmp.key的R[j]
		R[i]=R[j];				//找到这样的R[j],放入R[i]处
		while (i<j && R[i].key<=tmp.key)
			i++;				//从左向右扫描,找一个大于tmp.key的R[i]
		R[j]=R[i];				//找到这样的R[i],放入R[j]处
	}
	R[i]=tmp;
	return i;
}
void QuickSort(RecType R[],int s,int t) //对R[s..t]的元素进行快速排序
{	int i;
	RecType tmp;
	if (s<t) 					//区间内至少存在两个元素的情况
	{	
		i=partition(R,s,t);
		QuickSort(R,s,i-1);		//对左区间递归排序
		QuickSort(R,i+1,t);		//对右区间递归排序
	}
}

 

 

6.简单选择排序

选择排序(Selection-sort)是一种简单直观的排序算法。它的工作原理：首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。 

 算法描述

n个记录的直接选择排序可经过n-1趟直接选择排序得到有序结果。具体算法描述如下：

  • 初始状态：无序区为R[1..n]，有序区为空；
  • 第i趟排序(i=1,2,3…n-1)开始时，当前有序区和无序区分别为R[1..i-1]和R(i..n）。该趟排序从当前无序区中-选出关键字最小的记录 R[k]，将它与无序区的第1个记录R交换，使R[1..i]和R[i+1..n)分别变为记录个数增加1个的新有序区和记录个数减少1个的新无序区；
  • n-1趟结束，数组有序化了。

 动图演示

void SelectSort(RecType R[],int n)
{
	int i,j,k;
	RecType temp;
	for (i=0;i<n-1;i++)    	 	//做第i趟排序
	{
		k=i;
		for (j=i+1;j<n;j++)  	//在当前无序区R[i..n-1]中选key最小的R[k]
			if (R[j].key<R[k].key)
				k=j;           	//k记下目前找到的最小关键字所在的位置
			if (k!=i)          		//交换R[i]和R[k]
			{
				temp=R[i];
				R[i]=R[k];
				R[k]=temp;  
			}
	}
}

 

 

7.堆排序

堆排序（堆排序）是指利用堆这种数据结构所设计的一种排序算法堆积是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。

算法描述

动图演示

  • 将初始待排序关键字序列（R1，R2 ... .Rn）构建成大顶堆，此堆为初始的无序区;
  • 将堆顶元素R [1]与最后一个元素 - [R [n]的交换，此时得到新的无序区（R1，R2，...... Rn中-1）和新的有序区（RN），且满足ř并[1,2，...，N-1] <= R [N];
  • 由于交换后新的堆顶R [1]可能违反堆的性质，因此需要对当前无序区（R1，R2，...... Rn中-1）调整为新堆，然后再次将R [1]与无序区最后一个元素交换，得到新的无序区（R1，R2 ... .Rn-2）和新的有序区（RN-1，RN）的。不断重复此过程直到有序区的元素个数为ñ -1，则整个排序过程完成。
void sift(RecType R[],int low,int high)
{
	int i=low,j=2*i;     					//R[j]是R[i]的左孩子
	RecType temp=R[i];
	while (j<=high) 
	{
		if (j<high && R[j].key<R[j+1].key) 	//若右孩子较大,把j指向右孩子
			j++;    						//变为2i+1
		if (temp.key<R[j].key) 
		{
			R[i]=R[j];              		//将R[j]调整到双亲结点位置上
			i=j;                    		//修改i和j值,以便继续向下筛选
			j=2*i;
		}
		else break;                 		//筛选结束
	}
	R[i]=temp;                      		//被筛选结点的值放入最终位置
}

void HeapSort(RecType R[],int n)
{
	int i;
	RecType tmp;
	for (i=n/2;i>=1;i--)	//循环建立初始堆,调用sift算法 n/2 次
		sift(R,i,n); 
	for (i=n;i>=2;i--)		//进行n-1趟完成推排序,每一趟堆排序的元素个数减1
	{	tmp=R[1];			//将最后一个元素与根R[1]交换
		R[1]=R[i];
		R[i]=tmp;
		sift(R,1,i-1);		//对R[1..i-1]进行筛选,得到i-1个节点的堆
	}
}

 

8.二路归并排序

该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。将已有序列的子序列合并，得到完全有序的序列;即先使每个子序列有序，再使子序列段间有序若将两个有序表合并成一个有序表，称为2-路归并。 

算法描述

  • 把长度为Ñ的输入序列分成两个长度为N / 2的子序列;
  • 对这两个子序列分别采用归并排序;
  • 将两个排序好的子序列合并成一个最终的排序序列。

动图演示

//自底向上的二路归并排序算法

void Merge(RecType R[],int low,int mid,int high) 
{
	RecType *R1;
	int i=low,j=mid+1,k=0; //k是R1的下标,i、j分别为第1、2段的下标
	R1=(RecType *)malloc((high-low+1)*sizeof(RecType));  //动态分配空间
	while (i<=mid && j<=high)     	//在第1段和第2段均未扫描完时循环
		if (R[i].key<=R[j].key)    	//将第1段中的记录放入R1中
		{
			R1[k]=R[i];
			i++;k++; 
		}
		else                       		//将第2段中的记录放入R1中
		{
			R1[k]=R[j];
			j++;k++; 
		}
	while (i<=mid)          	       	//将第1段余下部分复制到R1
	{ 
		R1[k]=R[i];
		i++;k++; 
	}
    while (j<=high)                	//将第2段余下部分复制到R1
	{
		R1[k]=R[j];
		j++;k++;  
	}
    for (k=0,i=low;i<=high;k++,i++) //将R1复制回R中
	    R[i]=R1[k];
} 
void MergePass(RecType R[],int length,int n)	//对整个数序进行一趟归并
{
	int i;
	for (i=0;i+2*length-1<n;i=i+2*length) 	//归并length长的两相邻子表
		Merge(R,i,i+length-1,i+2*length-1);
	if (i+length-1<n-1)                		//余下两个子表,后者长度小于length
		Merge(R,i,i+length-1,n-1);  		//归并这两个子表
}
void MergeSort(RecType R[],int n)			//自底向上的二路归并算法
{
	int length;
	for (length=1;length<n;length=2*length)//进行log2n趟归并
		MergePass(R,length,n);
}





//自顶向下的二路归并排序算法

void Merge(RecType R[],int low,int mid,int high) 
{
	RecType *R1;
	int i=low,j=mid+1,k=0; //k是R1的下标,i、j分别为第1、2段的下标
	R1=(RecType *)malloc((high-low+1)*sizeof(RecType));  //动态分配空间
	while (i<=mid && j<=high)     	//在第1段和第2段均未扫描完时循环
		if (R[i].key<=R[j].key)    	//将第1段中的记录放入R1中
		{
			R1[k]=R[i];
			i++;k++; 
		}
		else                       		//将第2段中的记录放入R1中
		{
			R1[k]=R[j];
			j++;k++; 
		}
	while (i<=mid)          	       	//将第1段余下部分复制到R1
	{ 
		R1[k]=R[i];
		i++;k++; 
	}
    while (j<=high)                	//将第2段余下部分复制到R1
	{
		R1[k]=R[j];
		j++;k++;  
	}
    for (k=0,i=low;i<=high;k++,i++) //将R1复制回R中
	    R[i]=R1[k];
} 
void MergeSortDC(RecType R[],int low,int high)
//对R[low..high]进行二路归并排序
{
	int mid;
	if (low<high)
	{	mid=(low+high)/2;
		MergeSortDC(R,low,mid);
		MergeSortDC(R,mid+1,high);
		Merge(R,low,mid,high);		
	}
}
void MergeSort1(RecType R[],int n)	//自顶向下的二路归并算法
{
	MergeSortDC(R,0,n-1);
}

 

9.基数排序

计算排序不是基于比较的排序算法，其核心在于将输入的数据值转化为键存储在额外开辟的数组空间中。作为一种线性时间复杂度的排序，计数排序要求输入的数据必须是有确定范围的整数。

算法描述

  • 找出待排序的数组中最大和最小的元素;
  • 统计数组中每个值为我的元素出现的次数，存入数组Ç的第我项;
  • 对所有的计数累加（从ç中的第一个元素开始，每一项和前一项相加）;
  • 反向填充目标数组：将每个元素我放在新数组的第C（ⅰ）项，每放一个元素就将C（ⅰ）减去1。

动图演示

//最低位优先的基数排序算法

void RadixSort(NodeType *&p,int r,int d) //实现基数排序:p为待排序序列链表指针,r为基数,d为关键字位数
{
	NodeType *head[MAXR],*tail[MAXR],*t;//定义各链队的首尾指针
	int i,j,k;
	for (i=0;i<=d-1;i++)           		//从低位到高位循环
	{	
		for (j=0;j<r;j++) 				//初始化各链队首、尾指针
			head[j]=tail[j]=NULL;
		while (p!=NULL)          		//对于原链表中每个结点循环
		{	
			k=p->data[i]-'0';   		//找第k个链队
			if (head[k]==NULL)   		//进行分配
			{
				head[k]=p;
				tail[k]=p;
			}
          	else
			{
              	tail[k]->next=p;
				tail[k]=p;
			}
            p=p->next;             		//取下一个待排序的元素
		}
		p=NULL;							//重新用p来收集所有结点
       	for (j=0;j<r;j++)        		//对于每一个链队循环
        	if (head[j]!=NULL)         	//进行收集
			{	
				if (p==NULL)
				{
					p=head[j];
					t=tail[j];
				}
				else
				{
					t->next=head[j];
					t=tail[j];
				}
			}
		t->next=NULL;					//最后一个结点的next域置NULL
	}
}

10.桶排序

桶排序是计数排序的升级版。它利用了函数的映射关系，高效与否的关键就在于这个映射函数的确定。桶排序（Bucket sort）的工作的原理：假设输入数据服从均匀分布，将数据分到有限数量的桶里，每个桶再分别排序（有可能再使用别的排序算法或是以递归方式继续使用桶排序进行排）。

算法描述

  • 设置一个定量的数组当作空桶;
  • 遍历输入数据，并且把数据一个一个放到对应的桶里去;
  • 对每个不是空的桶进行排序;
  • 从不是空的桶里把排好序的数据拼接起来。 

图片演示

function bucketSort(arr, bucketSize) {
	if (arr.length == = 0) {
		return arr;
	}

	var i;
	var minValue = arr[0];
	var maxValue = arr[0];
	for (i = 1; i < arr.length; i++) {
		if (arr[i] < minValue) {
			minValue = arr[i];                // 输入数据的最小值
		}
		else if (arr[i] > maxValue) {
			maxValue = arr[i];                // 输入数据的最大值
		}
	}

	// 桶的初始化
	var DEFAULT_BUCKET_SIZE = 5;            // 设置桶的默认数量为5
	bucketSize = bucketSize || DEFAULT_BUCKET_SIZE;
	var bucketCount = Math.floor((maxValue - minValue) / bucketSize) + 1;
	var buckets = new Array(bucketCount);
	for (i = 0; i < buckets.length; i++) {
		buckets[i] = [];
	}

	// 利用映射函数将数据分配到各个桶中
	for (i = 0; i < arr.length; i++) {
		buckets[Math.floor((arr[i] - minValue) / bucketSize)].push(arr[i]);
	}

	arr.length = 0;
	for (i = 0; i < buckets.length; i++) {
		insertionSort(buckets[i]);                      // 对每个桶进行排序，这里使用了插入排序
		for (var j = 0; j < buckets[i].length; j++) {
			arr.push(buckets[i][j]);
		}
	}

	return arr;
}

 

欲游山河
关注
  • 3
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
常用十大排序算法
qq_51664685的博客
04-26 12万+
列举了常见的十大内部排序算法：插入排序、希尔排序、选择排序、冒泡排序、归并排序、快速排序、堆排序、基数排序，计数排序，桶排序。
十大经典排序算法总结整理
ytusdc的博客
10-12 4605
参考文章： 十大经典排序算法最强总结：https://www.cnblogs.com/guoyaohua/p/8600214.html 排序算法总结:https://www.runoob.com/w3cnote/sort-algorithm-summary.html 术语说明 内排序：所有排序操作都在内存中完成； 外排序：由于数据太大，因此把数据放在磁盘中，而排序通过磁盘和内存的数...
《Qt 实战一二三》
热门推荐
青春不老，奋斗不止！
12-12 34万+
Qt 基础与实战，主要包含：环境搭建、信号槽、事件机制、数据类型、常用部件/布局、对话框、QPainter 绘图等内容。
十大排序算法（Top 10 Sorting Algorithms）
果冻の技术星球
07-05 9786
十种常见排序算法可以分为两大类： 比较类排序：通过比较来决定元素间的相对次序，由于其时间复杂度不能突破O(nlogn)，因此也称为非线性时间比较类排序。 非比较类排序：不通过比较来决定元素间的相对次序，它可以突破基于比较排序的时间下界，以线性时间运行，因此也称为线性时间非比较类排序。......
初识 QML
青春不老，奋斗不止！
01-06 1万+
QML 是一种声明性语言，允许根据用户界面的可视组件以及它们如何相互交互和相互关联来描述用户界面。QML 是一种高度可读的语言，旨在使组件能够以动态方式互连，并且允许组件在用户界面中轻松重复使用和自定义。 使用 Qt Quick，开发人员可以轻松地在 QML 中构建流体动画用户界面，并且可以选择将这些用户界面连接到任何后端 C++ 库。
java十大排序算法实现
最新发布
11-20
java十大排序算法实现 1. 冒泡排序（Bubble Sort） 2. 选择排序（Selection Sort） 3. 插入排序（Insertion Sort） 4. 快速排序（Quick Sort） 5. 归并排序（Merge Sort） 6. 堆排序（Heap Sort） 7. 计数排序...
python十大排序算法
07-26
使用 python 实现十种最常见的排序算法：选择排序、冒泡排序、插入排序、归并排序、桶排序、计数排序、基数排序、（随机）快速排序、希尔排序和堆排序算法。 适用于数据结构与算法的学习过程中，也是面试过程中常被...
十大经典排序算法.pdf
12-08
十大经典排序算法 排序算法是《数据结构与算法》中最基本的算法之一。 排序算法可以分为内部排序和外部排序，内部排序是数据记录在内存中 进行排序，而外部排序是因排序的数据很大，一次不能容纳全部的排序 记录，在...
Python 3实现十大排序算法
12-13
个人总结十大排序算法的Python 3 实现，实测可运行。具体包括：-1 插排-2 希尔-3 选择-4 快排-5 冒泡-6 堆排-7 归并-8 计数-9 桶排-10 基数
十大经典排序算法Java版（动图演示）
Kahcc的博客
09-14 1953
文章目录0 排序算法说明0.1 内部排序和外部排序0.2 比较类排序和非比较类排序0.3 关于时间复杂度0.4 关于稳定性0.5 名词解释：1 交换排序——冒泡排序（Bubble Sort）1.1 什么时候最快1.2 什么时候最慢1.3 算法步骤1.4 动图演示1.5 Java实现2 选择排序——直接选择排序（Selection Sort）2.1 算法步骤2.2 动图演示2.3 Java实现3 插...
十大经典排序算法
牵LV小猪精的博客
05-05 1万+
十大经典排序算法 根据算法的时间空间复杂度列出以下10种排序算法，其中蓝色底的为稳定排序，绿色底的为不稳定排序。 先谈一谈稳定性：稳定性简单来讲就是考虑排序后值相同的元素和排序前是否保持一致（如排序前a1和a2值相同，排序后仍是a1在前a2在后） 注：希尔排序时间复杂度在O(nlogn)~O(n2）之间 根据时间复杂度来划分成三小类排序 1.时间复杂度为O(n2) 1.1.冒泡排序（Bubble Sort） 简单的思想：数组中相邻元素两两比较[以左边大为例子，交换两者的位置]；每一次.
关于Qt
weixin_34345753的博客
11-14 608
什么是Qt Qt是一个针对桌面、嵌入式、移动设备的一个跨平台的应用程序开发框架，支持的平台包括Linux、OS X、Windows、VxWorks、QNX、Android、iOS、BlackBerry(黑莓)、Sailfish OS（旗鱼操作系统）等。 Qt 1991年由Trolltech-奇趣科技（成立于1994年）开发，2008...
c++ 不插入重复元素但也不排序_十大经典排序算法，看这篇文章就够了
weixin_39800971的博客
11-24 564
微信公众号：小超说如果你觉得对你有帮助，欢迎分享如果你想系统地学习，建议在电脑端阅读我想大家学习算法之旅的开端就是各种排序算法吧，的确，排序算法广泛的应用性以及它的简洁基础等性质是初学者的不二之选，那今天我就带着你复习回顾以下各种经典的排序算法吧！希望对你有所帮助！约定：我们的排序算法操作对象为整数数组，顺序为从小到大我们首先看一下今天的内容 (抱歉，冒泡排序被挡住了?)1.冒泡排序冒泡...
Qt之pro配置详解
weixin_34319999的博客
06-28 2725
简述 使用Qt的时候，我们经常会对pro进行一系列繁琐的配置，为方便大家理解、查找，现将常用的配置进行整理。 简述 配置 注释 CONFIG DEFINES DEPENDPATH DESTDIR FORMS HEADERS INCLUDEPATH LIBS MOC_DIR OBJECTS_DIR QT RCC_DIR RE...
十大经典排序算法（动图演示C++实现）
zhangsy_csdn的博客
06-12 1万+
参考：https://www.cnblogs.com/onepixel/articles/7674659.html 十大经典排序算法（动图演示C++实现） 0、算法概述 0.1 算法分类 十种常见排序算法可以分为两大类： （选泡插，快归堆希统计基） 比较类排序：通过比较来决定元素间的相对次序，由于其时间复杂度不能突破O(nlogn)，因此也称为非线性时间比较类排序。 非比较类排...
十大经典排序算法【快速了解】
HelloWorld的博客
03-04 1072
十种常见排序算法

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值