排序算法的总结，思考和优化

最新推荐文章于 2024-05-08 16:46:46 发布
最新推荐文章于 2024-05-08 16:46:46 发布
阅读量363 收藏
点赞数
分类专栏： 算法 文章标签： 排序 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/abc_670/article/details/79548505
版权
稳定的
冒泡排序（bubble sort） — O(n^2）
鸡尾酒排序(Cocktail sort，双向的冒泡排序) — O(n^2）
插入排序（insertion sort）— O(n^2)
桶排序（bucket sort）— O(n); 需要 O(k) 额外空间
计数排序(counting sort) — O(n+k); 需要 O(n+k) 额外空间
合并排序（merge sort）— O(nlog n); 需要 O(n) 额外空间
原地合并排序— O(n^2)
二叉排序树排序 （Binary tree sort） — O(nlog n)期望时间； O(n^2)最坏时间； 需要 O(n) 额外空间
鸽巢排序(Pigeonhole sort) — O(n+k); 需要 O(k) 额外空间
基数排序（radix sort）— O(n·k); 需要 O(n) 额外空间
Gnome 排序— O(n^2)
图书馆排序— O(nlog n) with high probability，需要 （1+ε)n额外空间
不稳定的
选择排序（selection sort）— O(n^2)
希尔排序（shell sort）— O(nlog n) 如果使用最佳的现在版本
组合排序— O(nlog n)
堆排序（heapsort）— O(nlog n)
平滑排序— O(nlog n)
快速排序（quicksort）— O(nlog n) 期望时间，O(n^2) 最坏情况； 对于大的、乱数列表一般相信是最快的已知排序
Introsort— O(nlog n)
耐心排序— O(nlog n+ k) 最坏情况时间，需要 额外的 O(n+ k) 空间，也需要找到最长的递增子串行（longest increasing subsequence）
不实用的
Bogo排序— O(n× n!) 期望时间，无穷的最坏情况。
Stupid sort— O(n^3); 递归版本需要 O(n^2) 额外存储器
珠排序（Bead sort） — O(n) or O（√n)，但需要特别的硬件
Pancake sorting— O(n)，但需要特别的硬件

stooge sort——O（n^2.7）很漂亮但是很耗时

--摘自百度百科（排序算法）

冒泡排序：

（1）原版

for(int i = 0; i < n-1; i++)
	for(int j = i; j < n;j++)
		if(arr[j] > arr[j+1])
			swap(arr[j],arr[j+1]);




选择排序：（每次选出第i小/大的数）
（1）原版

for(int i = 0; i < n; i++)
{
	//选择当前最小的元素
	minIndex = i; 
	for(int j = i+1; j < n; j++)
		if(arr[j] < arr[minIndex])
			minIndex = j;
	swap(arr[i],arr[minIndex]);
}




插入排序：（每次跟前一个数据比较）

（1）原版

for(int i = 1; i < n; i++)
	//寻找arr[i]合适的插入位置
	for(int j = i; j > 0; j--)
		if(arr[j] < arr[j-1])
			swap(arr[j],arr[j-1]);
		else
		        break;

（2）代码简化版(将判断条件放入了if语句中，节省了代码量)

for(int i = 1; i < n; i++)
	for(int j = i; j > 0 && arr[j] < arr[j-1]; j--)
		swap(arr[j],arr[j-1]);

（3）效率优化版（将复杂的交换换成了比较，直接赋值）

for(int i = 1; i < n; i++)
	int e = arr[i];
	for(int j = i; j > 0 && arr[j-1] > e; j--)//寻找e应该插入的位置
		arr[j]=arr[j-1];
	arr[j] = e;
总结：虽然插入排序时间复杂度为O（n2），但是在处理有规律的数据的时候用效率优化版的代码甚至可以达到O（n）的程度，因为数据有规律时其实只有少部分数据需要进行赋值操作，并且比较次数也减少了，而在现实生活中其实有很多数据是有规律的，所以用插入排序可以达到很好的效果。



希尔排序

（1）原版

void shell_sort(int arr[],int lenth)
{
	int incre = lenth;
	while(true)
	{
		incre/=2;
		for(int k =0; k < incre;k++)//根据增量分为若干子序列
		{
			for(int i = k+incre;i<lenth;i+=incre)
			{
				for(int j = i; j>k; j-=incre)
				{
					if(arr[j] < arr[j-incre])
						swap(arr[j],arr[j-incre]);
					else
						break;
				}
			}
		}
		if(incre==1)
			break;
	}
}




归并排序

（1）原版

void Merge(int arr[],int lenth)//调用归并排序
{
	MergeSort(arr,0,n-1);
	return;
}

int MergeSort(int arr[],int l, int r)//递归排序
{
	if(l >= r)
		return;
	int mid = (l+r)/2;
	MergeSort(arr,l,mid);
	MergeSort(arr,mid,r);
	merge（arr,l,mid,r）;
}

void merge(int arr[],int l,int mid, int r)
{
	int temp[r-l+1];
	for(int i = l; i < r; i++)
		temp[i-l] = arr[i];
	
	int i = l, j = mid +1;
	for(int k = l; k <= r; k++)
	{
		if(i > mid)						//如果i和j超出范围，则直接赋值无需比较
			{arr[k] = arr[j-l];j++;}
		else if(j > r)
			{arr[k] = arr[i-l];i++}
		else if(temp[i-l] < temp[j-l])
			{arr[k] = temp[i-1];i++;}
		else
			{arr[k] = temp[j-1];j++}
	}
}


（2）优化

void Merge(int arr[],int lenth)//调用归并排序
{
	MergeSort(arr,0,n-1);
	return;
}

int MergeSort(int arr[],int l, int r)//递归排序
{
	if(r-l < 15)//数量级小的时候，可以用插入排序来加速，降低大量递归带来的性能影响
	{
		insertionSort(arr,l,r);
		return;
	}
	int mid = (l+r)/2;
	MergeSort(arr,l,mid);
	MergeSort(arr,mid,r);
	//因为两边的数组有序，先判断边界值是否也有序然后在决定是否要合并，这样效率更高
	if(arr[mid] > arr[mid+1])
		merge（arr,l,mid,r）;
}

void merge(int arr[],int l,int mid, int r)
{
	int temp[r-l+1];
	for(int i = l; i < r; i++)
		temp[i-l] = arr[i];
	
	int i = l, j = mid +1;
	for(int k = l; k <= r; k++)
	{
		if(i > mid)						//如果i和j超出范围，则直接赋值无需比较
			{arr[k] = arr[j-l];j++;}
		else if(j > r)
			{arr[k] = arr[i-l];i++}
		else if(temp[i-l] < temp[j-l])
			{arr[k] = temp[i-1];i++;}
		else
			{arr[k] = temp[j-1];j++}
	}
}

void insertionSort(int arr[], int l, int r)
{
	int lenth = r-1+1;
	for(int i =l+1; i < lenth; i++)
	{
		int e = arr[i]
		for(int j = i; j > l && arr[j-1] > e; j--)
			arr[j]=arr[j-1];
		arr[j]= e;
	}
}

（3）自底向上

void MergeBU（int arr[], int lenth）
{
	for(int sz = 1; sz <lenth; sz+=sz)
		for(int i = 0; i+sz< lenth; i+=sz+sz)
		//对arr[i,···i+sz-1]和arr[i+sz,···i+sz+sz-1]进行归并
			merge(arr,i,i+sz-1,min(i+sz+sz-1,n-1));//对数组边界进行限定，防止越界
}
void merge(int arr[],int l,int mid, int r)
{
	int temp[r-l+1];
	for(int i = l; i < r; i++)
		temp[i-l] = arr[i];
	
	int i = l, j = mid +1;
	for(int k = l; k <= r; k++)
	{
		if(i > mid)						//如果i和j超出范围，则直接赋值无需比较
			{arr[k] = arr[j-l];j++;}
		else if(j > r)
			{arr[k] = arr[i-l];i++}
		else if(temp[i-l] < temp[j-l])
			{arr[k] = temp[i-1];i++;}
		else
			{arr[k] = temp[j-1];j++}
	}
}



总结：归并排序先用二分法降低排序规模再进行排序达到了O(nlogn)的时间复杂度，在排序大量无序数据的时候，效率肯定是要比O(n2)的算法要高。不过原版的归并排序其实也有可以改进的地方，比如说在用递归拍好了两边数组的顺序后，如果能先判断一下这两个数组连起来是否已经有序，若无序在进行归并，有序则直接跳过归并数组的操作。而且因为两边数组已经有序，所以判断连起来是否有序只需判断边界值，一个if语句就能实现，在性能上是可以接受的。

另外一个优化的地方是数组长度为1的时候直接return，这样肯定会出现大量的递归操作，如果在长度比较小的时候，利用优化的插入排序直接排序，则可以避免这种损失。而且在较小规模的时候，插入排序算法确实能起到加速的作用！




快速排序

（1）原版

//对arr[l···r]进行partition操作
//返回索引p，使得arr[l···p-1]<arr[p],arr[l···p+1]>arr[p]
int partition(int arr[],int l,int r)
{
	int k = arr[l];
	int j = l;
	for(i = l+1; i < r;i++)
		if(arr[i] < k)
			swap(arr[++k],arr[i]);
	swap(arr[l],arr[j]);
	
	return j;
	
}
//对arr[l,····r]进行快速排序
void quicksort(int arr[],int l,int r)
{
	if(l>=r)
		return;
	int p = partition(arr,l,r);
	
	quicksort(arr,l,p-1);
	quicksort(arr,p+1,r);
}

void quick（int arr[],int lenth）
{
	quicksort(arr,0,lenth-1 );
}

(2)优化

//对arr[l···r]进行partition操作
//返回索引p，使得arr[l···p-1]<arr[p],arr[l···p+1]>arr[p]
int partition(int arr[],int l,int r)
{
	//随机选择第一个数，避免了算法复杂度退化为O（n2）
	swap(arr[l],arr[rand()%(r-l+1)]);
	
	int k = arr[l];
	int j = l;
	for(i = l+1; i < r;i++)
		if(arr[i] < k)
			swap(arr[++k],arr[i]);
	swap(arr[l],arr[j]);
	
	return j;
	
}
//对arr[l,····r]进行快速排序
void quicksort(int arr[],int l,int r)
{

	if(r-l < 15)//数量级小的时候，可以用插入排序来加速，降低大量递归带来的性能影响
	{
		insertionSort(arr,l,r);
		return;
	}
	int p = partition(arr,l,r);
	
	quicksort(arr,l,p-1);
	quicksort(arr,p+1,r);
}

void quick（int arr[],int lenth）
{
	quicksort(arr,0,lenth-1 );
}

（3）再优化

//对arr[l···r]进行partition操作
//返回索引p，使得arr[l···p-1]<arr[p],arr[l···p+1]>arr[p]
int partition(int arr[],int l,int r)
{
	//随机选择第一个数，避免了算法复杂度退化为O（n2）
	swap(arr[l],arr[rand()%(r-l+1)]);
	int k = arr[l];
	//arr[l+1···i]<=k,arr[j···r]>=k
	int i=l+1,j=r;
	while(true)//这样处理是为了出现大量等于k的元素时，依旧能平均的分在两边，这样就能避免算法在处理大量重复元素的时候退化到O（n2）
	{
		while(i <=r && arr[i]<=k) i++;
		while(j > l && arr[j]>=k) j--;
		if(i > j)	break;
		swap(arr[i],arr[j]);
		i++;
		j--;
	}
	return j;
	
}
//对arr[l,····r]进行快速排序
void quicksort(int arr[],int l,int r)
{

	if(r-l < 15)//数量级小的时候，可以用插入排序来加速，降低大量递归带来的性能影响
	{
		insertionSort(arr,l,r);
		return;
	}
	int p = partition(arr,l,r);
	
	quicksort(arr,l,p-1);
	quicksort(arr,p+1,r);
}

void quick（int arr[],int lenth）
{
	quicksort(arr,0,lenth-1 );
}

快速三路排序

//对arr[l···r]进行partition操作
//返回索引p，使得arr[l···p-1]<arr[p],arr[l···p+1]>arr[p]
int partition3ways(int arr[],int l,int r)
{
	//随机选择第一个数，避免了算法复杂度退化为O（n2）
	swap(arr[l],arr[rand()%(r-l+1)]);
	int k = arr[l];
	//arr[l+1···i]<=k,arr[j···r]>=k
	int lt= l;//arr[l+1···lt]<k
	int gt = r+1;arr[gt···r]>k
	int i = l+1;//arr[lt+1···i]==k
	
	while(i < gt)
	{
		if(arr[i] < k)
			{swap(arr[++lt],arr[i]);i++;}
		else if(arr[i]>k)
			swap(arr[--gt],arr[i]);
		else
			i++;
	}
	swap(arr[l],arr[lt]);
}

//对arr[l,····r]进行快速排序
void quicksort3ways(int arr[],int l,int r)
{

	if(r-l < 15)//数量级小的时候，可以用插入排序来加速，降低大量递归带来的性能影响
	{
		insertionSort(arr,l,r);
		return;
	}
	int p = partition(arr,l,r);
	
	quicksort3ways(arr,l,p-1);
	quicksort3ways(arr,p+1,r);
}

void quick3ways（int arr[],int lenth）
{
	quicksort3ways(arr,0,lenth-1 );
}


LqL_1
关注
专栏目录
十大排序算法及其优化
qq_53077771的博客
07-05 987
通过重新排列表中的元素，使表中的元素满足按关键字有序的过程。为了查找方便,通常希望计算机中的表是按关键字有序的。
排序算法及优化
weixin_51601437的博客
06-30 571
常见排序算法及其优化前言一、冒泡排序二、插入排序1.优化插入排序三、希尔排序四、选择排序五、快速排序1.素颜快速排序2.优化快速排序3.非递归实现快速排序六、归并排序七、堆排序八、其他排序1.计数排序2.基数排序3.桶排序九、海量数据排序问题总结 前言 内排序 ：将数据存储在内存上，在内存上进行的排序 外排序：将数据存储在外存上（例如磁盘，硬盘）排序的 一、冒泡排序 1.冒泡排序是一种稳定的排序，思想就是遍历数组是将相邻的两个元素进行比较，值大的就往后面放，一趟冒泡排序的结果就是将数组中最大的值放到了最后
高级排序算法实现与优化
weixin_34301132的博客
09-23 106
本文用到的测试数据生成的代码和分析：《测试数据自动生成》 文章图片来源于 GitHub，网速不佳的朋友请点我看原文。 顺便软广一下个人技术小站：godbmw.com。欢迎常来 ♪(^∇^*) 1. 谈谈高级排序 本文主要介绍高级排序算法中的归并排序和快速排序。他们有运用了分支思想，并且大多通过递归来实现。 对于归并排序，分为自上向底和自底...
常见排序算法总结思考(java实现算法)
lxprmcq的博客
11-12 140
重点总结了几种常见的算法
排序算法 总结&思考（一）
tianhaoray的专栏
05-28 594
--前言 排序算法是最基本而且最基础的问题，特别是在C语言中。在C++,JAVA等面向对象设计中通常会提供相应的库函数，使得编程者不必要考虑详细的设计处理，调用即可。即便如此，这一问题仍然是面试笔试中必然涉及到的话题。写一篇自己对各种排序算法的认识，作为以后找工作的基础吧 1.简单易懂 の 直接插入排序（InsertSort） 谈到排序，日常接触最多的例子就是扑克牌的顺序调整，因为分
排序算法思想总结
liangtianmeng的专栏
04-28 934
对于一名码农来说，熟悉数据结构和算法是最基本的，总结了一下各种排序算法的思想： 例如：一个待排序数列a = [1 4 7 2 5 8 3 6 9]，要求从小到大排序 一、冒泡排序 对待排序数列从最后一位元素开始依次比较大小，一次循环比较n-1次之后即可将最小值放在首位，即a[n-1]与a[n-2]，a[n-2]与a[n-3]...a[1]与a[0]，如果a[n-1]小于a[n-2]则
java算法，数据结构，排序算法，学习路线.zip
10-07
6. 重点学习排序算法，对比各种排序算法的效率和特性，尝试编写和优化代码。 7. 探究高级算法，如动态规划、贪心算法、回溯和分支限界法。 8. 实践项目，将所学应用于实际问题，如设计和实现一个简单的数据结构库...
74从零开始学Java之排序算法中的冒泡和选择排序
最新发布
一一哥
05-08 1172
我们要想成为一个优秀的程序员，其实非常关键的一点就是要锻炼培养自己的编程思维，就好比一个狙击手，要通过大量的射击训练要用大量的子弹喂出来。同样的，一个优秀的程序员，他的逻辑和编程思维，也是靠大量的训练锻炼出来的，而这个训练经常是通过各种“算法”来实现的。所以作为一个从零开始学习的小白，我们必然要学习各种编程算法。这些算法，一方面可以锻炼我们的编程思维，另一方面也是为了完成工作，很多项目中都会或多或少的用到一些算法，并且程序员面试时，算法也是必考的一项。基于这些因素，接下来壹哥。
排序算法 - 面试中的排序算法总结
从零开始
01-17 2832
排序算法总结 查找和排序算法是算法的入门知识，其经典思想可以用于很多算法当中。因为其实现代码较短，应用较常见。所以在面试中经常会问到排序算法及其相关的问题。但万变不离其宗，只要熟悉了思想，灵活运用也不是难事。 一般在面试中最常考的是快速排序和归并排序，并且经常有面试官要求现场写出这两种排序的代码。对这两种排序的代码一定要信手拈来才行。还有插入排序、冒泡排序、堆排序、基数排序、桶排序等。面试官对
如何分析一个排序算法及常见问题
@另维
04-17 1048
如何分析一个排序算法？ 算法的执行效率： 最好、最坏、平均时间复杂度(对于同一阶时间复杂度的排序算法性能对比可能会把系数、常数和低阶考虑到)基于比较的排序算法执行的适合会涉及到元素比较大小和元素的移动与交换，所以分析效率的时，比较次数、交换或者移动的次数也可以考虑进去 排序算法的内存消耗 原地排序，指空间复杂度是 O(1) 的排序算法。 排序算法的稳定性 待排序序列中存在值相等的元素，经过排序之...
冒泡排序总结
qq_41825377的博客
08-05 2115
冒泡排序总结算法思想：图片演示代码冒泡排序常规版：冒泡排序优化第一版冒泡排序优化第二版 算法思想： 冒泡排序是一种交换排序。 交换排序就是通过元素按照要求进行两两比较，判断是否符合要求，假如不符合要求就将两个元素交换位置来达到排序的目的。 冒泡排序名字的由来就是因为在交换过程中，类似水冒泡，小（大）的元素经过不断的比较交换由水底慢慢的浮到水的顶端。 冒泡排序的思想就是利用的比较交换，利用循环将第 i 小或者大的元素归位，归位操作利用的是对 n 个元素中相邻的两个进行比较，如果顺序正确就不交换，如果顺序错误就
十大经典排序算法详解及优化
Hello_GY 的博客
06-10 6511
算法概述 0.1 算法分类 十种常见排序算法可以分为两大类： 非线性时间比较类排序： 通过比较来决定元素间的相对次序，由于其时间复杂度不能突破O(nlogn)，因此称为非线性时间比较类排序。 包括：交换排序（冒泡、快速排序）插入排序（简单插入排序、希尔排序）选择排序（简单选择排序、堆排序）归并排序（二路，多路） 线性时间非比较类排序： 不通过比较来决定元素间的相对次序，可以突破基于比...
排序算法的总结和使用思考
Hanniboo's Blog
02-13 394
  下面这篇文章总结了7种常见的排序算法和图解。记录下方便以后工作中需要时直接拿来用。 https://blog.csdn.net/wang18741337665/article/details/82120413 个人认为排序最好的情况是走数据库索引的排序（又快又稳定），其次是数据库没有索引时做排序（相对较慢较消耗性能，但是安全稳定，做小集合排序没有问题），不能用数据库提供排序时再考虑用ja...
排序算法的优化 拓展
晓东的博客
02-28 536
、、 排序算法的优化 排序算法中的错误
各种排序算法的实现及优化
z595054650的专栏
04-06 527
import java.util.Random;public class Sort { private void swap(int[] arr,int i,int j){ int temp=0; temp=arr[i]; arr[i]=arr[j]; arr[j]=temp; } /** * 打印数组
快速排序算法及优化
m0_37541228的博客
06-19 533
基本思想： 1）选择一个基准元素,通常选择第一个元素或者最后一个元素, 2）通过一趟排序讲待排序的记录分割成独立的两部分，其中一部分记录的元素值均比基准元素值小。另一部分记录的 元素值比基准值大。 3）此时基准元素在其排好序后的正确位置 4）然后分别对这两部分记录用同样的方法继续进行排序，直到整个序列有序。 快速排序的示例： （a）一趟排序的过程：
十大排序3--选择排序及附代码
qq_44236958的博客
11-02 194
十大排序-插入排序 插入排序 Insertion Sort 基本思想: 在要排序的一组数中,假定前n-1个数已经排好序,现将第n个数插到前面的有序数列中,使得这n个数也是排好顺序. 算法描述 从第一个元素开始,该元素可以被认为已经被排序 取出下一个元素,在已经排序的元素序列中从后向前扫描 如果该元素(已排序)大于新元素,将该元素移动到下一位置 重复步骤三,直到直到已经排序的元素最小或者等于新元素的位置 将新元素插入到该位置后 重复步骤2~5 代码 private static int[] in
排序算法总结：冒泡、选择与直接插入排序
"这篇文章是关于各种排序算法的总结，适合初学者学习，涵盖了作者在学习排序算法时的思考和总结，旨在通过学习排序算法来培养算法思维。文章中提到了冒泡排序、简单选择排序和直接插入排序这三种常见的排序算法，并...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值