各种排序之间的比较和实现

最新推荐文章于 2020-04-15 12:12:49 发布
最新推荐文章于 2020-04-15 12:12:49 发布
阅读量613 收藏 1
点赞数 1
分类专栏： code
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cfy1024/article/details/76400732
版权

 hi，有强迫症麽？是不是每次看见乱七八糟的数字，都慌慌慌的~ 嘿嘿，介绍几个排序给你认识，从此让你过上整齐哒幸福生活~

 每个人都有优缺点，辣么，排序当然也有啦，先放个镇家之宝（自我感觉蛮漂亮的，O(∩_∩)O）~~~


下来，轮到每个排序的自我介绍啦~

一、插入排序法

开场白：我的特点呢，就是插插插，当然必须找合适的位置插入咯。
花样展示：啊呜~默认从小到大排序哦~~

代码实现： 
#include<iostream>
using namespace std;

void Insertsort(int *arr,int len)
{
	if(arr == NULL || len<=0)   //判断参数是否合理
	{
		return;
	}
	for(int i=1;i<len;++i) //关键词从第二个数据开始
	{
		int j = i-1;
		int tmp = arr[i]; //一定要记得保存成临时变量，因为挪动数据很可能把它盖住。
		while(tmp < arr[j] && j>=0) //如果比关键字大，就往后找，直到找到比它小的
		{
			arr[j+1] = arr[j];
			--j;
		}
		arr[j+1] = tmp; //把关键字插入到合适的位置
	}
}

int main()
{
	int num = 0;	
	cin>>num; //输入数组长度
	int *array = new int[num];
	for(int i=0;i<num;++i)
	{
		cin>>array[i]; //输入数组内容
	}
	Insertsort(array,num); //调用排序函数
	for(int i=0;i<num;++i)
	{
		cout<<array[i]<<" "; //输出数组内容
	}
	cout<<endl;
	delete[] array;
	return 0;
}
 总结：不难看出，我关键字的左边都是有序的，最好的情况呢，就是按序排着呢，走走走，不用换的，最坏呢，就是
倒序，走一部，挪n步的。所以呢，我最大的优点就是排有序的快啊，而且，我老老实实一个一个比较，当然稳定啦，哈哈~~~

二、希尔排序

开场白：我的特点就是分组咯，组内进行排序，然后减少组数。
花样展示：啊呜~默认从小到大排序哦~~

代码展示： 
#include<iostream>
#include<math.h>
using namespace std;
void shell(int *arr,int len,int gap) //gap 组数
{
	if(arr == NULL || len<=0 ||gap<0)   //判断参数是否合理
	{
		return;
	}
	int j = 0;
	for(int i=gap;i<len;++i) //从第gap个元素往后排
	{
		int tmp = arr[i];
		for(j=i-gap;j>=0;j-=gap)
		{
			if(arr[j] > tmp) //如果前面的组内有大于它的，就往后走，保证了组内关键字之前有序
			{
				arr[j+gap] = arr[j];
			}
			else
			{
				break;
			}
		}
		arr[j+gap] = tmp;
	}
}

void shellsort(int *arr,int len) 
{
	if(arr == NULL || len<=0)   //判断参数是否合理
	{
		return;
	}
	int num = (int)sqrt(len) +1;//这个可以按照自己的想法写，想分几组分几组，我是觉得这样合理一些。
	int *gap = new int[num]; 
	cout<<"the number is: "<<num<<endl;
	cout<<"please input gaps: "<<endl;
	for(int i=0;i<num;++i)  //输入分组情况
	{
		cin>>gap[i];
	}
	for(int i=0;i<num;++i)  //分别调用子函数
	{
		shell(arr,len,gap[i]);
	}
}

int main()
{
	int num = 0;	
	cin>>num; //输入数组长度
	int *array = new int[num];
	for(int i=0;i<num;++i)
	{
		cin>>array[i]; //输入数组内容
	}
	shellsort(array,num); //调用排序函数
	for(int i=0;i<num;++i)
	{
		cout<<array[i]<<" "; //输出数组内容
	}
	cout<<endl;
	delete[] array;
	return 0;
}
总结：希尔排序比插入排序多了一个分组过程，组内的排序方式和插入是一样的，插入法排序在有序的情况下快嘛，所以它就利用这个特性进一步优化，使得数组越来越逼近于有序，从而达到时间复杂度较为小一点，所以，他也可以称为是插入法排序的“哥”，但是呢，它不稳定，因为组内排序，有可能相同的数据并没有分在一个组里，所以整体看起来数据就在飞。

三、冒泡排序

开场白：咿呀呀，吐呀吐呀吐泡泡，两两比较，轻的往上走，重的往下沉~
花样展示：
代码展示： 
#include<iostream>
using namespace std;

void Bubblesort(int *arr,int len)
{
	if(arr == NULL || len<=0)   //判断参数是否合理
	{
		return;
	}
	for(int i=len-1;i>0;--i) 
	{
		for(int j=0;j<i;++j)
		{
			if(arr[j] > arr[j+1])
			{
				int tmp = arr[j];
				arr[j] = arr[j+1];
				arr[j+1] = tmp;
			}
		}
	}
}
int main()
{
	int num = 0;	
	cin>>num; //输入数组长度
	int *array = new int[num];
	for(int i=0;i<num;++i)
	{
		cin>>array[i]; //输入数组内容
	}
	Bubblesort(array,num); //调用排序函数
	for(int i=0;i<num;++i)
	{
		cout<<array[i]<<" "; //输出数组内容
	}
	cout<<endl;
	delete[] array;
	return 0;
}
总结：冒泡最大的优点就是思路简单，代码简单，但是如果它有序的话，可以遍历一次就结束，当然，你得加一个计数器，保证它这一遍的遍历没有任何交换数据的现象出现~

四、快速排序

开场白：我叫快速排序，那么我快呀~找个基准，小于我的往前走，大于我的往后走，找准位置，插入进去，然后换个基准，重复过程，直到走完~
花样展示：

代码展示： 
#include<iostream>
#include<math.h>
using namespace std;

int Partion(int *arr,int low,int high)//一次划分过程
{
     if(arr == NULL || low>=high || low<0 || high<0)
           return -1;

     int tmp = arr[low];
     while(low < high)
     {
           while((arr[high]>=tmp) && (low<high))//因为high在变，所以第二个条件不能省略
           {
                high --;
           }
           if(low == high) //判断是否结束循环
                break;
           else
                arr[low] = arr[high]; //小值往前
           while((arr[low]<=tmp) && (low<high))//因为low在变，所以第二个条件不能省略
           {
                low ++;
           }
           if(low == high)//判断是否结束循环
                break;
           else
                arr[high] = arr[low];//大值往后
     }
     arr[low] = tmp; //关键词入位
     return low;
}
/递归
void Quick(int *arr,int low,int high)
{
     int par = Partion(arr,low,high); //调用一次划分函数
     if(par != -1)
     {
           if(low<par-1) //至少有两个元素
           {
                Quick(arr,low,par-1);//左边继续调用划分函数
           }
           if(par<high)  //至少有两个元素
           {
                Quick(arr,par+1,high);//右边继续调用划分函数
           }
     }
}
void QuickSort(int *arr,int len) //马甲函数，方便调用
{
     if(arr == NULL || len <= 0)
           return;
     Quick(arr,0,len-1);
}
int main()
{
	int num = 0;	
	cin>>num; //输入数组长度
	int *array = new int[num];
	for(int i=0;i<num;++i)
	{
		cin>>array[i]; //输入数组内容
	}
	QuickSort(array,num); //调用排序函数
	for(int i=0;i<num;++i)
	{
		cout<<array[i]<<" "; //输出数组内容
	}
	cout<<endl;
	delete[] array;
	return 0;
}
总结：这个方法呢，时间复杂度是比较小的，但是它的缺点一个是需要辅助空间，因为有递归啊，所以空间复杂度就是log2n。

五、选择排序

 开场白：原则就是挑最小的一直往前走， 挑待排序中最小的与第一个交换。
 花样展示：

代码展示： 
#include<iostream>
#include<math.h>
using namespace std;

void ChooseSort(int *arr,int len)//选择排序
{
	if(arr == NULL || len <= 0)//参数判断
	{
		return;
	}
	for(int i=0;i<len-1;++i)
	{
		int tmp = arr[i]; //用一个临时变量保存当前最小值
		int pos = -1;    //当前最小值所对应的下标
		int j = i + 1;   //待排序中，找最小的值以及它的下标
		for(;j<len;++j)
		{
			if(tmp > arr[j])
			{
				tmp = arr[j];
				pos = j;
			}
		}
		if(pos != -1)//证明待排序中有比第一个数据小的值
		{
			arr[pos] = arr[i]; //把第一个数据放在最小值处
		}
		arr[i] = tmp; //把最小值挪到第一个位置
	}
}

int main()
{
	int num = 0;	
	cin>>num; //输入数组长度
	int *array = new int[num];
	for(int i=0;i<num;++i)
	{
		cin>>array[i]; //输入数组内容
	}
	ChooseSort(array,num); //调用排序函数
	for(int i=0;i<num;++i)
	{
		cout<<array[i]<<" "; //输出数组内容
	}
	cout<<endl;
	delete[] array;
	return 0;
}
总结：感觉跟冒泡有点相似，不同的是冒泡两两比较，顺序不对就交换，而选择排序一直是找最小的与第一个交换，

六、归并排序

开场白：哥两好呀，二路并呀，二路并完四路并，四路并完八路并，越并越整齐呀~
花样展示：

代码展示： 
#include<iostream>
using namespace std;

void Merge(int *arr,int len,int gap)//一次归并过程，gap是组的元素个数，假设二路每组一个元素，四路每组两个元素
{
	if(arr==NULL || len<=0 || gap <1)
	{
		return;
	}
	int low1 = 0;//不管几路归并，都是从头开始的；
	int high1 = low1 + gap - 1;//n个元素应该走n-1步
	int low2 = low1 + gap;
	int high2 = low2+gap< len ? low2 + gap -1:len-1;//有可能凑不够，一定要注意不可以越界

	int *brr = new int[len];//申请一个临时数组，保存归并后的新数组
	int index = 0;//表示brr的下标值

	//只要low2小于len，则证明有两个组可以进行归并
	while(low2 < len)
	{
		//组内都有元素剩余
		while(low1<=high1 && low2<=high2)
		{
			if (arr[low2] < arr[low1])
			{
				brr[index++] = arr[low2++];
			}
			else
			{
				brr[index++] = arr[low1++];
			}
		}

		//第一组有剩余
		while(low1 <= high1)
		{
			brr[index++] = arr[low1 ++];
		}
		//第二组有剩余
		while(low2 <= high2)
		{
			brr[index++] = arr[low2 ++];
		}

		//更新组
		low1 = high2+1;
		high1 = low1+gap-1;
		low2 = high1+1;
		high2 = low2+gap<len ? low2+gap-1 : len-1;
	}

	//归并段不成对,则只有一个组，直接挪动数据即可
	while(low1 < len)
	{
		brr[index++] = arr[low1++];
	}
	//把临时数组的值赋值给旧数组
	for(int i=0;i<len;i++)
	{
		arr[i] = brr[i];
	}

	delete[] brr;
}
void MergeSort(int *arr,int len)
{
	if(arr==NULL || len<=0) //参数检查
	{
		return;
	}
	for(int i=1;i<len;i*=2)
	{
		Merge(arr,len,i);
	}
}
int main()
{
	int num = 0;	
	cin>>num; //输入数组长度
	int *array = new int[num];
	for(int i=0;i<num;++i)
	{
		cin>>array[i]; //输入数组内容
	}
	MergeSort(array,num); //调用排序函数
	for(int i=0;i<num;++i)
	{
		cout<<array[i]<<" "; //输出数组内容
	}
	cout<<endl;
	delete[] array;
	return 0;
}
总结：归并的思想很重要哟，在某些问题上，可以考虑考虑这种分治思想，过程中一定要注意下标，千万不要越界。不管他很有序还是很无序，该干哈的还是在干哈，所以说他的最好最坏和平均时间复杂度都是一样的，因为他是按序慢慢排的，也不牵扯数据的飞来飞去，所以他还是稳定的~

七、堆排序

 开场白：大根堆，小根堆，调整一次找到一个~
花样展示：
代码展示： 
#include<iostream>
#include<assert.h>
using namespace std;

void HeapAdjust(int *arr,int start,int end) //调整函数
{//O(logn),O(1),
	int tmp = arr[start]; 
	int parent = start;

	for(int i=2*parent+1;i<=end;i=2*i+1)
	{
		if((i+1<=end) && (arr[i]<arr[i+1]))
		{
			++i;
		}//i一定是左右孩子较大值的下标

		if(tmp < arr[i])
		{
			arr[parent] = arr[i];
			parent = i;
		}
		else
		{
			//arr[parent] = tmp;
			//return ;
			break;
		}
	}
	arr[parent] = tmp;
}
void HeapSort(int *arr,int len)//O(nlogn),O(1),不稳定
{
	//第一个建大根堆
	int i;
	int tmp;
	for(i=(len-1-1)/2;i>=0;i--)//O(nlogn)
	{
		HeapAdjust(arr,i,len-1);
	}

	for(i=0;i<len-1;i++)//O(nlogn)
	{
		tmp = arr[0];
		arr[0] = arr[len-1-i];
		arr[len-1-i] = tmp;

		HeapAdjust(arr,0,len-i-1-1);//已经有序的数据不参与调整
	}
}
int main()
{
	int num = 0;	
	cin>>num; //输入数组长度
	int *array = new int[num];
	for(int i=0;i<num;++i)
	{
		cin>>array[i]; //输入数组内容
	}
	HeapSort(array,num); //调用排序函数
	for(int i=0;i<num;++i)
	{
		cout<<array[i]<<" "; //输出数组内容
	}
	cout<<endl;
	delete[] array;
	return 0;
}
总结：堆函数就是建好一个大根堆，以后就容易多啦，它特别适合去找一个最大的呀，前十个最大的呀，这种问题。

大大大大大总结：每个排序都各有千秋，根据题目的要求选择最适合的算法才是最重要哒，么么哒~~~ 整理不易~~~~给自己一个么么么么么哒~~~~~~
1024个秘密
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
各种排序算法总结和比较
11-30 3010
排序算法可以说是一项基本功，解决实际问题中经常遇到，针对实际数据的特点选择合适的排序算法可以使程序获得更高的效率，有时候排序的稳定性还是实际问题中必须考虑的，这篇博客对常见的排序算法进行整理，包括：插入排序、选择排序、冒泡排序、快速排序、堆排序、归并排序、希尔排序、二叉树排序、计数排序、桶排序、基数排序。 代码都经过了CodeBlocks的调试，但是很可...
C++实现各种排序算法.zip
最新发布
10-10
总的来说，这个压缩包"**C++实现各种排序算法.zip**"为我们提供了一个宝贵的资源库，可以帮助我们学习和比较不同排序算法的实现，从而提升编程技能，更好地解决实际问题。通过阅读和分析这些代码，我们可以深入理解...
各种排序的比较和使用场景分析
热门推荐
lizhao007
04-20 1万+
冒泡排序           冒泡排序重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说排序完成。规模比较小的时候应用冒泡排序，主要应用于教学。。。 选择排序--只会移动N次          选择排序的主要思想：首先找到数组中最小的那个元素，其次，将它和第一个元素交换。接下来找第二小和第二个交换。运
各种排序比较
simply the best
12-12 642
#include using namespace std; typedef const int& itemType ; typedef bool (*cmp)( itemType a, itemType b); bool myless(const int& a,const int& b) { return a<b; } template void myswap(T& a,T&
实现二叉排序树的各种算法
07-25
实验过程中，学生可能还会探讨不同场景下二叉排序树的表现，比如在已排序和未排序的数据集上构建树的差异，以及在不平衡树和平衡树之间进行操作的效率对比。通过这样的实践，学生能深入理解二叉排序树的原理，并提高...
Ruby实现的各种排序算法
09-22
通过上述各种排序算法的介绍和 Ruby 实现，我们可以看到每种排序算法都有其适用场景。选择正确的排序算法可以显著提高程序运行效率。例如，在数据量不大且接近有序的情况下，可以选择插入排序；而在大数据量排序时，...
各种排序算法比较1
08-03
这里我们探讨三种排序算法：直接插入排序、希尔排序（优化的插入排序）和选择排序，以及提到但未给出完整实现的堆排序和快速排序。这些算法在解决LeetCode等在线编程挑战时常常被用到。 1. **直接插入排序**： ...
几种排序算法的比较
Gary's Blog --- A C++ programmer
09-10 4869
 一、引言排序算法，是计算机编程中的一个常见问题。在日常的数据处理中，面对纷繁的数据，我们也许有成百上千种要求，因此只有当数据经过恰当的排序后，才能更符合用户的要求。因此，在过去的数十载里，程序员们为我们留下了几种经典的排序算法，他们都是智慧的结晶。本文将带领读者探索这些有趣的排序算法，其中包括介绍排序算法的某些基本概念以及几种常见算法，分析这些算法的时间复杂度，同时在最后将介绍我们独创的
各种排序算法比较
11-20
常用的排序算法进行比较和总结，以及如何排序的思想
各种排序算法对比
02-04
各种排序算法的实现，并通过随机生成10万个数进行算法时间效率的比较
各种排序问题（数据结构设计）
01-03
各种排序问题（数据结构设计） 冒泡排序，随机排序等
各种排序性能比较
le119126的专栏
03-28 1327
1. 性能与初始位置无关的 堆、归并、二分插入 ：因为都是原始数据对半分开比较排序 选择排序：比较次数与初始位置无关，交换次数有关 2.性能与初始位置有关 冒泡：如果不设置标志，比较次数与初始化位置无关，但是如果设置标志，对于已经排序的序列，第一趟冒泡就知道全都排好序了 插入排序：排序与否影响插入位置，移动元素个数 -------------------------------
[算法] 各种排序比较
四月晴
06-24 773
排序的稳定性和时间复杂度 不稳定： 快排 O(nlogn)O(nlogn)O(nlog^n) 平均时间， 最坏情况O(n2)O(n2)O(n^2) 堆排序 O(nlogn)O(nlogn)O(nlog^n) 选择排序 O(n2)O(n2)O(n^2) 希尔排序 O(nlogn)O(nlogn)O(nlog^n) 稳定： 冒泡排序 O(n2)O(n2)O(n^2) 插入排序 O(n2...
内部排序之间的比较
qq_39745932的博客
09-25 194
各种排序性能对比如下，有些排序未详细介绍，暂且放到这里。实例测试结果可以看这里：八大排序算法耗时对比。 排序类型 平均情况 最好情况 最坏情况 辅助空间 稳定性 冒泡排序 O(n²) O(n) O(n²) O(1) 稳定 选择排序 O(n²) O(n²) O(n²) O(1) 不稳定 直接插入排...
各种排序算法的对比分析
hearting的博客
04-15 2472
排序 算法的时间复杂度主要取决与比较和交换的次数。空间复杂度看是否需要额外的内存空间存储数组的副本。 冒泡排序法 比较相邻的元素。如果第一个比第二个大，就交换他们两个，依次类推。最好时间复杂度O(n)，平均时间复杂度O(n²)。空间复杂度O(1)。 选择排序法 在数组中找出最小的元素，与第一个元素交换位置，依次类推。 比较的次数为你n*(n-1)/2,交换的次数为n-1。时间复杂度O(n²)，...
算法12：各类排序比较
pplin的专栏
03-24 324
未完待续
比较各类排序算法的时间效率
"这篇资源是关于数据结构课程设计的一个任务，目标是对七种常见的排序算法——直接插入排序、希尔排序、起泡排序、快速排序、直接选择排序、堆排序和归并排序——进行时间性能比较。设计者需要实现这些算法，并在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值