排序算法的C++实现与性能分析（插入排序、归并排序、快速排序、STOOGE排序、堆排序）

最新推荐文章于 2022-09-07 17:54:56 发布
最新推荐文章于 2022-09-07 17:54:56 发布
阅读量2k 收藏 4
点赞数 2
分类专栏： 算法 文章标签： 算法导论 排序算法 快速排序 归并排序 堆排序
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiqingnian/article/details/24669603
版权

选择排序、快速排序、希尔排序、堆排序不是稳定的排序算法

冒泡排序、插入排序、归并排序和基数排序都是稳定的排序算法。

各种算法的稳定性分析：http://www.cnblogs.com/Braveliu/archive/2013/01/15/2861201.html

总结：

（1）如果数据量非常小，那么适合用简单的排序算法：冒泡排序，选择排序和插入排序。因为他们虽然比较次数多，但是移动次数少。比如，如果记录的关键字本身信息量比较大（比如关键字都是数十位的数字），那么占用存储空间比较大，这样移动记录所花费的时间也就很多。因此，应该尽量少移动。

（2）如果数据量非常大，那么就用快排。快排可以对pivot的选择进行优化，一般优化方式是三数取中，即左端，右端，中间三个数取中值。

（3）如果快排表现不好，也就时由于选择pivot的原因，排序朝着二次幂的方向发展，那么就采用堆排序。

（4）SGI STL中的Sort()函数就是采用的上述方式。

（5）堆排序对空间的要求很小，如果软件执行环境非常在乎内存，那么请选择堆排序。

（6）堆排序和归并排序都是最好，最坏，平均情况的效率都是O(nlogn)，如果程序非常在乎稳定性请选择归并排序。


0X00.冒泡排序


typedef struct SqList
{
<span style="white-space:pre">	</span>int r[MAXSIZE+1];
<span style="white-space:pre">	</span>int length;
}SqList;

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


void BubbleSort(SqList *L)
{
	for(int i=1;i<L->length;i++)
	{
		for(int j=L->length;j>i;j--)
		{
			if(L->r[j]<L->r[j-1])
				swap(L,j,j-1);	//swap(L,j,j-1);
		}
	}
}

0X01.选择排序 

void SelectSort(SqList *L)
{
	for(int i=1;i<L->length;i++)
	{
		int min=i;
		for(int j=i+1;j<=L->length;j++)
		{
			if(L->r[j]<L->r[min])
				min=j;
		}
		if(min!=i)
			swap(L,i,min);
	}
}



0X02、插入排序（INSERTION-SORT）

#include <iostream>
#include <stdlib.h>
using namespace std;

//插入排序
void insertion_sort(int a[],unsigned int first,unsigned int last)
{
	int j,i;
	int key;
	for(j=first+1;j<=last;j++)
	{
		key=a[j];
		i=j-1;
		while(i>=first&&key<a[i])
		{
			a[i+1]=a[i];
			i=i-1;
		}
		a[i+1]=key;
	}
}

//打印数组
void printnumber(int a[],int count)
{
	int i;
	for(i=0;i<count;i++)
		cout<<a[i]<<"  ";
	cout<<endl;
}

int main()
{
	int count;
	cout<<"Please input the num of numbers:"<<endl;
	cin>>count;
	while(count<=0)
	{
		cout<<"There should be more than 0 numbers!"<<endl;
		cout<<"Please input again:"<<endl;
		cin>>count;
	}

	int *a=new int [count];
	cout<<"Please input the "<<count<<" numbers:"<<endl;
	
	int i,num;
	for(i=0;i<count;i++)
	{
		cin>>num;
		*(a+i)=num;
	}
	cout<<"The numbers before sorted:"<<endl;
	printfnumber(a,count);

	insertion_sort(a,0,count-1);

	cout<<"The numbers after sorted:"<<endl;
	printnumber(a,count);

	delete []a;

	system("pause");
	
}

0X03、归并排序（MERGE-SORT）

#include <iostream>
#include <stdlib.h>

using namespace std;

//A[p...q;q+1...r]
void merge(int A[],int p,int q,int r)
{
	int i,j,k,n1,n2;
	//n1,n2分别用来记录两个数组的数据个数
	n1=q-p+1;
	n2=r-q;
	//数组的第一个位置没有用来存放数据
	int *L=new int[n1+2];
	int *R=new int[n2+2];
	//分别用L，R来记录两个待排序数组
	for(i=1;i<=n1;i++)
		L[i]=A[p+i-1];
	for(j=1;j<=n2;j++)
		R[j]=A[q+j];
	//将两个数组的最后数值都设置为较大值:10000
	L[n1+1]=10000;
	R[n2+1]=10000;

	i=j=1;
	//将L，R两个数组中较小者先放入数组A中
	for(k=p;k<=r;k++)
	{
		if(L[i]<=R[j])
		{
			A[k]=L[i];
			i++;
		}
		else
		{
			A[k]=R[j];
			j++;
		}
	}
	delete []L;
	delete []R;
}

//归并排序
void merge_sort(int A[],int p,int r)
{
	if(p<r)
	{
		int q;
		q=(p+r)/2;
		merge_sort(A,p,q);
		merge_sort(A,q+1,r);
		merge(A,p,q,r);
	}
}

//打印数组
void printnumber(int A[],int count)
{
	int i;
	for(i=0;i<count;i++)
		cout<<*(A+i)<<" ";
}

void main()
{
	cout<<"MERGE-SORT is running!"<<endl;
	cout<<"Please input the quantity of the numbers:"<<endl;
	int count;
	cin>>count;
	while(count<=0)
	{
		cout<<"There should be more than 0 numbers!"<<endl;
		cout<<"Please re-input again:"<<endl;
		cin>>count;
	}
	cout<<"Please input the "<<count<<"numbers:"<<endl;
	int i;
	int *A=new int[count];
	for(i=0;i<count;i++)
		cin>>*(A+i);

	cout<<"The numbers before sorted:"<<endl;
	printnumbers(A,count);
	cout<<"MERGE-SORT-ing..."<<endl;
	merge_sort(A,0,count-1);
	cout<<"The numbers after sorted:"<<endl;
	printnumber(A,count);
	delete []A;
	system("pause");
}

0X04、快速排序（快排、QUICK-SORT）

这是算法导论上的思路：

#include <iostream>
#include <stdlib.h>

using namespace std;

//分组
int PARTITION(int A[],int p,int r)
{
	int i,j,x,temp;
	x=A[r];
	i=p-1;
	
	for(j=p;j<=r-1;j++)
	{
		if(A[j]<=x)
		{
			i++;
			temp=A[i];
			A[i]=A[j];
			A[j]=temp;
		}
	}
	temp=A[i+1];
	A[i+1]=A[r];
	A[r]=temp;

	return i+1;
}

//快排
void QUICK_SORT(int A[],int p,int r)
{
	if(p<r)
	{
		int q;
		q=PARTITION(A,p,r);
		QUICK_SORT(A,p,q-1);
		QUICK_SORT(A,q+1,r);
	}
}

//打印数组
void printnumber(int A[],int count)
{
	int i;
	for(i=0;i<count;i++)
		cout<<*(A+i)<<" ";
	cout<<endl;
}

void main()
{
	cout<<"QUICK-SORT is running!"<<endl;
	cout<<"Please input the quantity of the numbers:"<<endl;
	int count;
	cin>>count;
	while(count<=0)
	{
		cout<<"There should be more than 0 numbers!"<<endl;
		cout<<"Please re-input the quantity:"<<endl;
		cin>>count;
	}

	cout<<"Please input the "<<count<<"numbers:"<<endl;
	int i;
	int *A=new int[count];
	//A[0...count-1]
	for(i=0;i<count;i++)
		cin>>*(A+i);

	cout<<"The numbers before sorted:"<<endl;
	printnumber(A,count);
	QUICK_SORT(A,0,count-1);
	cout<<"The numbers after sorted:"<<endl;
	printnumber(A,count);

	system("pause");
}


这是一般的思路：

int Partition(SqList *L,int low,int high)
{
	int pivotkey=L->r[low];

	while(low<high)
	{
		while(low<high&&L->r[high]>pivotkey)
			high--;
		swap(L,low,high);

		while(low<high&&L->r[low]<pivotkey)
			low++;
		swap(L,low,high);
	}

	return low;
}


void QSort(SqList *L,int low,int high)
{
	int pivot;
	if(low<high)
	{
		pivot=Partition(L,low,high);

		QSort(L,low,pivot-1);
		QSort(L,pivot+1,high);
	}
}


0X05、STOOGE排序（STOOGE-SORT）

#include <iostream>
#include <stdio.h>

using namespace std;

//STOOGE排序
void STOOGE_SORT(int A[],int i,int j)
{
	if(A[i]>A[j])
	{
		int temp;
		temp=A[i];
		A[i]=A[j];
		A[j]=temp;
	}

	if(i+1>=j)
		return;

	int k=(j-i+1)/3;

	STOOGE_SORT(A,i,j-k);
	STOOGE_SORT(A,i+k,j);
	STOOGE_SORT(A,i,j-k);
}

//打印数组
void printnumber(int A[],int count)
{
	int i;
	for(i=0;i<count;i++)
		cout<<*(A+i)<<" ";
	cout<<endl;
}

void main()
{
	cout<<"STOOGE-SORT is running!"<<endl;
	cout<<"Please input the quantity of the numbers:"<<endl;
	int count;
	cin>>count;
	while(count<=0)
	{
		cout<<"There should be more than 0 numbers!"<<endl;
		cout<<"Please re-input the quantity:"<<endl;
		cin>>count;
	}

	cout<<"Please input the "<<count<<" numbers:"<<endl;
	int i;
	int *A=new int[count];
	for(i=0;i<count;i++)
		cin>>*(A+i);

	cout<<"The numbers before sorted:"<<endl;
	printnumber(A,count);
	cout<<"STOOGE-SORT-ing..."<<endl;
	STOOGE_SORT(A,0,count-1);
	cout<<"The numbers after sorted:"<<endl;
	printnumber(A,count);

	system("pause");
}

0X06、堆排序（HEAP-SORT）

利用最大堆。

#include <iostream>
#include <stdio.h>

using namespace std;

//内联函数，用于计算父亲节点、左孩子节点、右孩子节点
inline int PARENT(int i){return i/2;}
inline int LEFT(int i){return 2*i;}
inline int RIGHT(int i){return 2*i+1;}

//说明：A[1,..,heapsize]，数组A的A[0]不用，实际，length（A）=heapsize+1。
//该函数用于保持堆的性质
void MAX_HEAPIFY(int A[],int i,int heapsize)
{
	int l,r,temp,largest=0;
	l=LEFT(i);
	r=RIGHT(i);

	//找到A[i],A[l],A[r]三者中的最大值
	if(l<=heapsize&&A[l]>A[i])
		largest=l;
	else
		largest=i;

	if(r<=heapsize&&A[r]>A[largest])
		largest=r;

	//如果拥有最大值的不是根节点i，那么将A[i]和A[largest]进行交换
	//并递归调用MAX_HEAPIFY()对孩子节点进行处理
	if(largest!=i)
	{
		temp=A[i];
		A[i]=A[largest];
		A[largest]=temp;

		MAX_HEAPIFY(A,largest,heapsize);
	}
}

//该函数用于构建最大堆
void BUILD_MAX_HEAP(int A[],int heapsize)
{
	int i;
	for(i=heapsize/2;i>=1;i--)
		MAX_HEAPIFY(A,i,heapsize);
}

//堆排序
void HEAP_SORT(int A[],int length)
{
	//首先构建最大堆
	BUILD_MAX_HEAP(A,length);

	int i,temp,heapsize=length;
	for(i=heapsize;i>=2;i--)
	{
		//将最大的A[1]和末尾的A[i]交换，即：将当前堆中的最大值移到末尾
		temp=A[1];
		A[1]=A[i];
		A[i]=temp;
		//堆的大小减一
		heapsize--;
		//对根节点进行调整，即：重新构建当前的最大堆
		MAX_HEAPIFY(A,1,heapsize);
	}
}

//用于打印数组的函数
void printnumber(int A[],int heapsize)
{
	int i;
	for(i=1;i<=heapsize;i++)
		cout<<*(A+i)<<" ";
	cout<<endl;
}

void main()
{
	cout<<"MAX-HEAP-SORT is running"<<endl;
	cout<<"Please input the quantity of the numbers:"<<endl;
	
	//要求用户输入要输入的堆的大小，此处，数组的长度length=堆的大小heapsize+1
	int count;
	cin>>count;
	while(count<=0)
	{
		cout<<"There should be more than 0 numbers!"<<endl;
		cout<<"Please re-input the quantity:"<<endl;
		cin>>count;
	}

	//用户输入数组
	cout<<"Please input the "<<count<<" numbers:"<<endl;
	int i;
	int *A=new int[count+1];
	//A[1,..,count],heapsize=count-1+1=count;
	for(i=0;i<count;i++)
		cin>>*(A+i+1);

	//进行堆排序
	cout<<"The numbers before sorted:"<<endl;
	printnumber(A,count);
	HEAP_SORT(A,count);
	cout<<"The numbers after sorted:"<<endl;
	printnumber(A,count);
	
	delete []A;

	system("pause");
}

0X07.ShellSort（希尔排序）



void ShellSort(SqList *L)
{
	int i,j,increment=L->length;
	increment=increment/3+1;

	bool flag=true;

	while(increment>=1&&flag)
	{
		if(increment==1)
			flag=false;

		for(i=increment+1;i<=L->length;i++)
		{
			L->r[0]=L->r[i];
			
			for(j=i-increment;j>=1&&L->r[j]>L->r[0];j-=increment)
			{
				L->r[j+increment]=L->r[j];
			}
			L->r[j+increment]=L->r[0];
		}
		increment=increment/3+1;
	}
}

0X08.总结



0X09.其他排序


此外，还有其他排序方法包括：桶排序，计数排序，基数排序。

桶排序和计数排序基本一样，一个数组分别统计每个数出现的个数。

基数排序是先对个位数排序，然后对十位数排序，然后对百位数排序，以此类推。

西青年
关注
  • 2
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JAVA实现StoogeSort方法排序
12-04
JAVA实现StoogeSort方法排序，简单演示。
Java数据结构和算法 五种排序算法：选择排序、插入排序、冒泡排序、快速排序和归并排序的实现与性能分析
成名在望xy的博客
04-21 1232
排序 排序（sorting）是根据某些标准，将一组数据项按确定的次序重排，或为升序或为降序，例如按字母表顺序排列名字，或按降序排列测量结果。排序被认为是计算机科学的经典研究领域。 我们在此研究5个不同的排序算法：选择排序、插入排序、冒泡排序、快速排序和归并排序。前三种算法的效率差不多，但方法都有所不同。后两种算法的效率更高，也相对比较复杂。我将在本文的最后一节简要介绍评估算法复杂度的方法并比较这些排序算法。 选择排序 选择排序（selection sort）算法重复一个过程：分别将每个值放到排好序的最终位置
排序算法的实现及性能测试及比较
Rikkaの博客
12-23 4564
在书中，各种内部排序算法的时间复杂度分析结果只给出了算法执行时间的阶，或大概执行时间。试通过具体数据比较各种算法的关键字比较次数和记录移动次数，以取得直观感受。 要求： （1）编写程序创建一些整数文件用于排序。创建的这些文件可以根据需要生成不同的长度，如长度分别为20，200和2000，以正序、逆序、随机顺序的方式创建这些文件，通过把所有这些测试数据保存在文件中（而不是每次在测试程序时用随机数生成），可以使用同样的数据去测试不同的方法，因此会更易于比较这些方法的性能。 （2）数据表采用顺序存储结构，实现插入
三种排序方法的实现以及性能比较(快速排序,插入排序,选择排序)
cgy_gavy的博客
11-07 1190
本文来自于我自己的博客:https://abalone.life/archives/sortcompare 未经允许不得转载!若图片无法显示请前往上方我博客的链接! 最近开始学算法了,在学校搞定了三种排序,刚刚在家里实践,现在就依次讲讲吧 首先,我所说的排序就是将数组中的数据按照一定规律(升序或降序)排列 其次,我是用Java实现的,因此用到了泛型(为了算法能更广泛的运用) 那么就先依次上代码吧,在此之前我先利用Java的继承体系做了一个排序模板(里面记录了所有排序都必定会要用到的方法) Sort.ja
超详细的排序算法实现与分析(插入排序，归并排序，快速排序)
Krito.的博客
12-28 2480
比较排序的定义 在排序的最终结果中，各元素的次序依赖于它们之间的比较，我们把这类排序算法称为比较排序。 比较排序算法的下界 在最坏情况下，任何比较排序算法都需要做次比较。 证明: 考虑一颗高度为h，具有L个可达叶节点的决策树，它对应一个对n个元素所做的比较排序(如下图所示）。因为输入数据的n！种可能的排列都是叶节点，所以有n!<=L。由于在一颗高度为h1的二叉树中，叶节点的数目不多于,所以可以得到：n!<=...
【C++】十大排序算法原理、代码、时空复杂度and稳定性分析
saxon_li的博客
12-14 1109
前言：本文排序顺序均为从小到大 一、冒泡排序 1、算法描述 ⽐较相邻的元素。如果第⼀个⽐第⼆个⼤，就交换它们两个； 对每⼀对相邻元素作同样的⼯作，从开始第⼀对到结尾的最后⼀对，这样每一趟排序，所有未排序元素中最后的元素即是最⼤的数； 重复复以上两步骤 n - 1 次（ n 为数组的大小），直到排序完成。 2、代码展示 void bubbleSort(vector<int>& num) { int n=num.size(); for(int i=0;i
stooge_sort.zip_数据结构_Visual_C++_
08-11
桶排序算法，分治算法，输入一串数字，输出他们从小到大的排序
stooge_sort.zip_This Is It
最新发布
09-24
this program is stooge_sort that writted with c++. this program get an array and sort it in order nlogn.
email-stooge:电子邮件模板组装线
07-15
指示用于命令行npm install -g email-stoogeemail-stooge --help用于程序化用途npm install -g email-stooge var stooge = require ( 'stooge' ) ;stooge ( { sourceDir : '/path/to/templates' , distDir : '/path/...
常见的十种排序算法C++实现（附时空复杂度，稳定性分析）
Xavier_97的博客
09-07 3133
每一轮排序使得当前无序的部分的最大值冒到当前无序数组的末尾，下一轮中无序部分的长度等于上一轮减一，原数组的末端不断的变成有序的部分。时间复杂度最坏和平均情况是O()，最好的情况是已经有序所以是O(n)，空间复杂度O(1)，且因为两个相同的元素是不会交换位置的，因此是一种稳定的排序。
归并排序(C++语言描述）
11-09
使用C++书写的归并排序算法，希望对各位有用。也请大牛指教代码中有何不足的地方！
7种常用排序算法实现（C++）（冒泡排序、选择排序、直接插入排序、希尔排序、堆排序、归并排序以及快速排序）
04-11
本文件是7种常用排序算法的实现（C++），包括冒泡排序、选择排序、直接插入排序、希尔排序、堆排序、归并排序以及快速排序。代码详细有注释且有测试用例。
快速排序 快排 leetcode215题 性能分析（时间空间复杂度）
weixin_42217106的博客
04-21 209
背景 解题 -图片来自geek 快排： 如果要排序数组中下标从 p 到 r 之间的一组数据，我们选择 p 到 r 之间的任意一个数据作为 pivot（分区点）。 将小于 pivot 的放到左边，将大于 pivot 的放到右边，将 pivot 放到中间 可以这样放置 但是这样就不是原地的了，所以优化成如图 class Solution: def findKthLargest(self, nums: List[int], k: int) -> int: r = len(nu
七种排序算法 C++ 实现及性能分析
weixin_51068265的博客
06-29 434
七种排序算法 C++ 实现及性能分析
20200330-Timsort算法
weixin_41175072的博客
03-30 339
Timsort算法 冒泡排序 第 1 轮：依次比较第 1 和第 2 个，第 2 和第 3 个，…，第 n-1 和第 n 个元素，大的向后移，第 1 大的移到倒数第 1 个位置。 第 2 轮：依次比较第 1 和第 2 个，第 2 和第 3 个，…，第 n-2 和第 n-1 个元素，大的向后移，第 2 大的移到倒数第 2 个位置。 ▪ ▪ ▪ ▪ ▪ ▪ 第 n-1 轮：比较第 1 和第 2 个，大的...
快速排序的时间复杂度与空间复杂度
热门推荐
struggle_kid的博客
08-11 1万+
C/C++中快速排序的时间空间复杂度分析 1.什么是快速排序 我理解的是，快速排序用的是分治法，运用的递归的算法，先挑选一个基准值，小于基准值的数放在左边， 大于基准值的数放在基准值的右边，这样就泾渭分明的三块；但是这三块是有序的，基准值左边右边的内 部数是无序的，所以，将基准值左右两端继续进行快速排序，直到区间长度为1，排序就完成了。 2.快速排序代码实现 下面使用vs2013实现快速排序： 输出为： 3.快速排序的时间复杂度 每种排序方式都会有最优的时间复杂度以及最差的时间复杂度，就像快速排序，你
【C++】快速排序算法、代码、时空复杂度and稳定性分析
saxon_li的博客
12-11 2681
一、思想 1、基本思想：基于 交换 的高效排序算法，采用了 分治法 的思想。 2、算法描述： 从数列中取出一个数作为基准数（pivot，一般取数组第一个元素）； 把数组进行左右划分(partition)，大于基准数的元素都移至枢轴右边，小于等于基准数的元素都移至枢轴左边； 再对左右的子区间重复第二步的划分操作，直至每个子区间只有一个元素，排序完成。 3、复杂度： 复杂度 最坏时间复杂度 平均时间复杂度 最坏空间复杂度 平均空间复杂度 .
C/C++中四种排序算法的时间空间复杂度
struggle_kid的博客
08-11 8774
C/C++中四种排序算法的时间空间复杂度 一.浅谈时间复杂度和空间复杂度 1.概念： 时间复杂度：就是说执行算法需要消耗的时间长短，越快越好。 空间复杂度：就是说执行当前算法需要消耗的存储空间大小，也是越少越好。 2.时间复杂度： 1.表示方法： 一般用“大O符号表示法”来表示时间复杂度：T(n) = O(f(n))，n是影响复杂度变化的因子，f(n)是复杂度具体的算法。 1-1.循环次数最多原则： 当n变得越来越大时，公式中的低阶，常量，系数三部分影响不了其增长趋势，可以直接忽略他们， 只记录一个最
三个高级排序算法：快速排序、归并排序、堆排序
Gensoukyo
05-30 6817
接下来的三个高级排序算法，是在实践中经常使用的算法，比起基于比较和交换的三个简单的排序算法，有更快的速度。快速排序和归并排序都属于递归排序算法，对于递归排序算法来说很重要的就是对递归树的理解。 一、快速排序 快速排序使用了分治法的策略。它的基本思想是，选择一个基准数，通过一趟排序将要排序的数据分割成独立的两部分；其中一部分的所有数据都比另外一部分的所有数据都要小。然后，再按此方法对这两部分数据...
堆排序，快速排序，归并排序，插入排序总结及C++实现
qq_38469553的博客
03-30 1131
目录 1.堆排序 1.1堆 1.2维护堆的性质 1.3建堆 1.4堆排序算法 2.快速排序 3.归并排序 3.1原理 3.2代码实现 3.3时间复杂度 4.插入法排序 4.1原理 1.堆排序 1.1堆 堆是一个数组，可以看成一个近似的完全二叉树。除了最底层外树是完全充满的，并且从左到右填充。 表示堆的数组A有两个属性，一个是A.length，表示数组的大小；另一个是...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值