各种排序算法实现——基数排序、归并排序、插入排序、冒泡排序、选择排序、快速排序、堆排序、希尔排序

最新推荐文章于 2020-09-13 09:54:31 发布
最新推荐文章于 2020-09-13 09:54:31 发布
阅读量954 收藏 3
点赞数
分类专栏： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/huahuahailang/article/details/8716959
版权

各种排序算法总结见http://blog.csdn.net/huahuahailang/article/details/8716434

 

一、基数排序

#include<iostream>
#include<time.h>
using namespace std;
#define N 13 //取13个数字
#define d 3 //3位数字
#define K 10 //10个筒子
void RadixSort(int num[])
{ 
	int i,j,k; 
	int rate=1; 
	int C[N]; 
	int B[N];
	for (i=0;i<d;i++) 
	{
		for (j=0;j<K;j++)
		{ 
			C[j]=0;
		}
		for (j=0;j<N;j++)
		{ 
			k=num[j]/rate%10;//取出最后一位数字 
			C[k]++; 
		}
		for (j=1;j<K;j++) 
		{
			C[j] = C[j]+C[j-1];
		}
		for (j=N-1;j>=0;j--)
		{
			k=num[j]/rate%10; 
			B[C[k]-1]=num[j]; 
			C[k]--; 
		}
		cout<<"第 "<<i+1<<" 趟数据收集为："<<endl;
		for (j=0;j<N;j++)
		{
			num[j]=B[j]; cout<<B[j]<<" ";
		}
		cout<<endl; rate *=10; 
	}
}
int main(int argc,char *argv[])
{ 
	int i;
	int temp=1; 
	int num[N];
	srand((unsigned) time(NULL)); 
	for (i=0;i<d;i++) 
	{
		temp *= 10; 
	}
	for (i=0;i<N;i++) 
	{ 
		num[i]=rand()%temp;
	}
	cout<<"排序之前数组中的数字为："<<endl;
	for (i=0;i<N;i++)
	{
		cout<<num[i]<<" "; 
	} 
	cout<<endl<<endl;
	RadixSort(num);
	cout<<endl<<"使用基数排序之后："<<endl;
	for (i=0;i<N;i++)
	{
		cout<<num[i]<<" "; 
	}
	cout<<endl;
	return 0;
}



 二、归并排序

#include<iostream>
#include<time.h>
using namespace std;
#define N 13 //取13个数字
#define d 2  // 数字的最大位数
void merge(int num[],int p,int q,int r)
{
	int n1,n2,i,j,k;
	int L[N];
	int R[N];
	n1=q-p+1;
	n2=r-q;
	for (i=0;i<n1;i++)
	{
		L[i]=num[p+i];
	}
	for (j=0;j<n2;j++)
	{
		R[j]=num[q+1+j];
	}
	k=p;
	i=0;
	j=0;
	while ((k<r)&&(i<n1)&&(j<n2))
	{
		if (L[i]<=R[j])
		{
			num[k]=L[i];
			i++;
		}
		else
		{
			num[k]=R[j];
			j++;
		}
		k++;
	}
	while (i<n1)
	{
		num[k++]=L[i++];
	}
	while (j<n2)
	{
		num[k++]=R[j++];
	}
}
void merge_sort(int num[],int p,int r)
{
	int q;
	if (p<r)
	{
		q=(p+r)/2;
		merge_sort(num,p,q);
		merge_sort(num,q+1,r);
		merge(num,p,q,r);
	}
}
int main(int argc,char *argv[])
{
	int i;
	int temp=1;
	int num[N];
	srand((unsigned) time(NULL));
	for (i=0;i<d;i++)
	{
		temp *= 10;
	}
	for (i=0;i<N;i++)
	{
		num[i]=rand()%temp;
	}
	cout<<"随机生成的排序之前数组中的数字为："<<endl;
	for (i=0;i<N;i++)
	{
		cout<<num[i]<<"  ";
	}
	cout<<endl<<endl;;
	
	merge_sort(num,0,N-1);
	cout<<endl<<"使用归并排序之后："<<endl;
	for (i=0;i<N;i++)
	{
		cout<<num[i]<<"  ";
	}
	cout<<endl;
	return 0;
}


三、插入排序

#include<iostream>
#include<time.h>
using namespace std;
#define N 13 //取13个数字
#define d 2  // 数字的最大位数
void charu_sort(int num[])
{
	int i,j,k;
	int key;
	for (i=1;i<N;i++)
	{
		j=0;
		key=num[i];
		while (j<=i)
		{
			if (num[j]>key)
			{
				k=i;
				while (k>j)
				{
					num[k]=num[k-1];
					k--;
				}
				num[k]=key;
				break;
			}
			j++;
		}
	}
}
int main(int argc,char *argv[])
{
	int i;
	int temp=1;
	int num[N];
	srand((unsigned) time(NULL));
	for (i=0;i<d;i++)
	{
		temp *= 10;
	}
	for (i=0;i<N;i++)
	{
		num[i]=rand()%temp;
	}
	cout<<"随机生成的排序之前数组中的数字为："<<endl;
	for (i=0;i<N;i++)
	{
		cout<<num[i]<<"  ";
	}
	cout<<endl<<endl;;
	
	charu_sort(num);
	cout<<endl<<"使用插入排序之后："<<endl;
	for (i=0;i<N;i++)
	{
		cout<<num[i]<<"  ";
	}
	cout<<endl;
	return 0;
}

 

插入排序的另一种写法：

#include<iostream>
#include<time.h>
using namespace std;
#define N 13 //取13个数字
#define d 2  // 数字的最大位数
void charu_sort(int num[])
{
	int i,j;
	int key;
	for (i=1;i<N;i++)
	{
		key=num[i];
		j=i-1;
		while (j>=0&&key<num[j])
		{
			num[j+1]=num[j];
			j--;
		}
		num[j+1]=key;
	}
}
int main(int argc,char *argv[])
{
	int i;
	int temp=1;
	int num[N];
	srand((unsigned) time(NULL));
	for (i=0;i<d;i++)
	{
		temp *= 10;
	}
	for (i=0;i<N;i++)
	{
		num[i]=rand()%temp;
	}
	cout<<"随机生成的排序之前数组中的数字为："<<endl;
	for (i=0;i<N;i++)
	{
		cout<<num[i]<<"  ";
	}
	cout<<endl<<endl;;
	
	charu_sort(num);
	cout<<endl<<"使用插入排序之后："<<endl;
	for (i=0;i<N;i++)
	{
		cout<<num[i]<<"  ";
	}
	cout<<endl;
	return 0;
}

四、冒泡排序

#include<iostream>
#include<time.h>
using namespace std;
#define N 13 //取13个数字
#define d 2  // 数字的最大位数
void buffer_sort(int num[])
{
	int i,j;
	int temp;
	for (i=0;i<N-1;i++)
	{
		for (j=0;j<N-1-i;j++)
		{
			if (num[j]>num[j+1])
			{
				temp=num[j];
				num[j]=num[j+1];
				num[j+1]=temp;
			}
		}
	}
}
int main(int argc,char *argv[])
{
	int i;
	int temp=1;
	int num[N];
	srand((unsigned) time(NULL));
	for (i=0;i<d;i++)
	{
		temp *= 10;
	}
	for (i=0;i<N;i++)
	{
		num[i]=rand()%temp;
	}
	cout<<"随机生成的排序之前数组中的数字为："<<endl;
	for (i=0;i<N;i++)
	{
		cout<<num[i]<<"  ";
	}
	cout<<endl<<endl;;
	
	buffer_sort(num);
	cout<<endl<<"使用冒泡排序之后："<<endl;
	for (i=0;i<N;i++)
	{
		cout<<num[i]<<"  ";
	}
	cout<<endl;
	return 0;
}

 

五、选择排序

#include<iostream>
#include<time.h>
using namespace std;
#define N 13 //取13个数字
#define d 2  // 数字的最大位数
void choice_sort(int num[])
{
	int i,j,k;
	int temp;
	for (i=0;i<N-1;i++)
	{
		k=i;
		for (j=i+1;j<N;j++)
		{
			if (num[k]>num[j])
			{
				k=j;
			}
		}
		if (k!=i)
		{
			temp=num[i];
			num[i]=num[k];
			num[k]=temp;
		}
	}
}
int main(int argc,char *argv[])
{
	int i;
	int temp=1;
	int num[N];
	srand((unsigned) time(NULL));
	for (i=0;i<d;i++)
	{
		temp *= 10;
	}
	for (i=0;i<N;i++)
	{
		num[i]=rand()%temp;
	}
	cout<<"随机生成的排序之前数组中的数字为："<<endl;
	for (i=0;i<N;i++)
	{
		cout<<num[i]<<"  ";
	}
	cout<<endl<<endl;;
	
	choice_sort(num);
	cout<<endl<<"使用选择排序之后："<<endl;
	for (i=0;i<N;i++)
	{
		cout<<num[i]<<"  ";
	}
	cout<<endl;
	return 0;
}

 

 


六、快速排序

#include<iostream>
#include<time.h>
using namespace std;
#define N 13 //取13个数字
#define d 2  // 数字的最大位数
int Partition(int num[],int p,int r)
{
	int i,j;
	int X=num[p];
	i=p;
	j=r;
	while (i<j)
	{
		while (i<j&&num[j]>X)
		{
			j--;
		}
		num[i]=num[j];
		while (i<j&&num[i]<X)
		{
			i++;
		}

		num[j]=num[i];
	}
	num[i]=X;
	return i;
}
void quick_sort(int num[],int p,int r)
{
	int q;
	if (p<r)
	{
		q=Partition(num,p,r);
		quick_sort(num,p,q-1);   
		quick_sort(num,q+1,r);
	}
}
int main(int argc,char *argv[])
{
	int i;
	int temp=1;
	int num[N];
	srand((unsigned) time(NULL));
	for (i=0;i<d;i++)
	{
		temp *= 10;
	}
	for (i=0;i<N;i++)
	{
		num[i]=rand()%temp;
	}
	cout<<"随机生成的排序之前数组中的数字为："<<endl;
	for (i=0;i<N;i++)
	{
		cout<<num[i]<<"  ";
	}
	cout<<endl<<endl;;
	
	quick_sort(num,0,N-1);
	cout<<endl<<"使用快速排序之后："<<endl;
	for (i=0;i<N;i++)
	{
		cout<<num[i]<<"  ";
	}
	cout<<endl;
	return 0;
}



七、希尔排序：

#include<iostream>
#include<time.h>
#define N 13 //取13个数字
#define d 2 //3位数字
using namespace std;
void ShellPass(int num[],int increment)
{
	int i,j;
	int temp;
	for (i=increment;i<N;i++)
	{
		if (num[i]<num[i-increment])
		{
			temp=num[i];
			j=i-increment;
			do 
			{
				num[j+increment]=num[j];
				j=j-increment;
			} while (j>0&&temp<num[j]);
			num[j+increment]=temp;
		}
	}
}
void ShellSort(int num[])
{ 
	int increment=N;//增量
	do 
	{
		increment =increment/3+1;
		ShellPass(num,increment);
	} while (increment>1);
}
int main(int argc,char *argv[])
{ 
	int i;
	int temp=1; 
	int num[N];
	srand((unsigned) time(NULL)); 
	for (i=0;i<d;i++) 
	{
		temp *= 10; 
	}
	for (i=0;i<N;i++) 
	{ 
		num[i]=rand()%temp;
	}
	cout<<"排序之前数组中的数字为："<<endl;
	for (i=0;i<N;i++)
	{
		cout<<num[i]<<" "; 
	} 
	cout<<endl<<endl;
	ShellSort(num);
	cout<<endl<<"使用希尔排序之后："<<endl;
	for (i=0;i<N;i++)
	{
		cout<<num[i]<<" "; 
	}
	cout<<endl;
	return 0;
}



 八、堆排序

//大根堆实现由小到大的排序

#include<iostream>
#include<time.h>
#define N 8 //取13个数字
#define d 2 //3位数字
using namespace std;
void MaxHeap(int num[],int i,int len)
{
	int temp;
	int larger=i;
	int left=2*i;
	int right=2*i+1;
	if (left<=len&&num[left]>num[i])
	{
		i=left;
	}
	if (right<=len&&num[right]>num[i])
	{
		i=right;
	}
	if (i!=larger)
	{
		temp=num[larger];
		num[larger]=num[i];
		num[i]=temp;
		MaxHeap(num,i,len);
	}
	
}
void BuildMaxHeap(int num[],int len)
{
	int i,j,temp;
	i=len/2;
	while (i>=1)
	{
		MaxHeap(num,i,len);
		i--;
	}
}
void HeapSort(int num[],int len)
{ 
	int i;
	int temp;
	BuildMaxHeap(num,len);
	for (i=len;i>=2;i--)//将大根堆调整。将n--.
	{
		temp=num[i];
		num[i]=num[1];
		num[1]=temp;
		len --;
		MaxHeap(num,1,len);
	}
}
int main(int argc,char *argv[])
{ 
	int i;
	int temp=1; 
	int num[N+1];
	int len=N;
	srand((unsigned) time(NULL)); 
	for (i=0;i<d;i++) 
	{
		temp *= 10; 
	}
	for (i=1;i<=N;i++) 
	{ 
		num[i]=rand()%temp;
	}
	cout<<"排序之前数组中的数字为："<<endl;
	for (i=1;i<=N;i++)
	{
		cout<<num[i]<<" "; 
	} 
	cout<<endl<<endl;
	HeapSort(num,len);
	cout<<endl<<"使用堆排序之后："<<endl;
	for (i=1;i<=N;i++)
	{
		cout<<num[i]<<" "; 
	}
	cout<<endl;
	return 0;
}

//小根堆实现由大到小的顺序排序

#include<iostream>
#include<time.h>
#define N 13 //取13个数字
#define d 2 //3位数字
using namespace std;
void MaxHeap(int num[],int i,int len)
{
	int temp;
	int larger=i;
	int left=2*i;
	int right=2*i+1;
	if (left<=len&&num[left]<num[i])
	{
		i=left;
	}
	if (right<=len&&num[right]<num[i])
	{
		i=right;
	}
	if (i!=larger)
	{
		temp=num[larger];
		num[larger]=num[i];
		num[i]=temp;
		MaxHeap(num,i,len);
	}

}
void BuildMaxHeap(int num[],int len)
{
	int i,j,temp;
	i=len/2;
	while (i>=1)
	{
		MaxHeap(num,i,len);
		i--;
	}
}
void HeapSort(int num[],int len)
{ 
	int i;
	int temp;
	BuildMaxHeap(num,len);
	for (i=len;i>=2;i--)//将大根堆调整。将n--.
	{
		temp=num[i];
		num[i]=num[1];
		num[1]=temp;
		len --;
		MaxHeap(num,1,len);
	}
}
int main(int argc,char *argv[])
{ 
	int i;
	int temp=1; 
	int num[N+1];
	int len=N;
	srand((unsigned) time(NULL)); 
	for (i=0;i<d;i++) 
	{
		temp *= 10; 
	}
	for (i=1;i<=N;i++) 
	{ 
		num[i]=rand()%temp;
	}
	cout<<"排序之前数组中的数字为："<<endl;
	for (i=1;i<=N;i++)
	{
		cout<<num[i]<<" "; 
	} 
	cout<<endl<<endl;
	HeapSort(num,len);
	cout<<endl<<"使用堆排序之后："<<endl;
	for (i=1;i<=N;i++)
	{
		cout<<num[i]<<" "; 
	}
	cout<<endl;
	return 0;
}



 

huahuahailang
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java实现八个常用的排序算法：插入排序、冒泡排序、选择排序、希尔排序等
09-03
主要介绍了Java如何实现八个常用的排序算法：插入排序、冒泡排序、选择排序、希尔排序 、快速排序、归并排序、堆排序和LST基数排序,需要的朋友可以参考下
插入排序，归并排序，快速排序时间效率测试
TITLE
05-03 3066
随机产生100000个数据，分别用三种算法测试排序的时间，机器和代码都略渣。。。 /* 插入排序、归并排序、快速排序时间测试 */ #include &lt;stdio.h&gt; #include &lt;time.h&gt; #include &lt;stdlib.h&gt; #include &lt;limits.h&gt; #define N 100000 int n[N]; /...
[数据结构与算法]排序算法汇总(JavaScript版)
DaftJayee的博客
09-13 211
JavaScript所有排序算法汇总 一、冒泡排序 Array.prototype.bubbleSort = function () { for (let i = 0; i < this.length - 1; i++) { for (let j = 0; j < this.length - 1 - i; j++) { if (this[j] > this[j + 1]) {
基数排序的两种实现方法--Radix Sort
jinglong_mydog的博客
05-04 2932
基于c语言下的基数排序的数组和链表的实现思路
排序算法之基数排序 - JavaScript实现
Leo
05-16 1178
刚开始学，注释为自己的理解，敬请指正。// LSD Radix Sort // 比较整型 var counter = [];// 定义一个函数 arr待排序数组 maxDigit数组中最大数的位数，例如[1,10,100]的maxDigit为3 function radixSort(arr, maxDigit) { var mod = 10; var dev = 1; for
C++实现八个常用的排序算法：插入排序、冒泡排序、选择排序、希尔排序等
09-03
主要介绍了C++如何实现八个常用的排序算法：插入排序、冒泡排序、选择排序、希尔排序 、快速排序、归并排序、堆排序和LST基数排序,需要的朋友可以参考下
c语言实现冒泡排序、希尔排序等多种算法示例
12-31
实现以下排序插入排序O(n^2) 冒泡排序 O(n^2) 选择排序 O(n^2) 快速排序 O(n log n) 堆排序 O(n log n) 归并排序 O(n log n) 希尔排序 O(n^1.25) 1.插入排序 O(n^2) 一般来说，插入排序都采用in-place在数组上实现。...
各类排序算法实现程序，包括冒泡排序、选择排序、插入排序、希尔排序、归并排序、快速排序、堆排序、计数排序、桶排序、基数排序
03-06
各种排序算法的实现函数：包括冒泡排序、选择排序、插入排序、希尔排序、归并排序、快速排序、堆排序、计数排序、桶排序、基数排序。 查找最大最小值函数 findMinMax：在给定数组中查找最大值和最小值。 计算平均值...
C/C++排序算法实现，冒泡排序、简单选择排序、直接插入排序、希尔排序、堆排序、归并排序、快速排序
12-26
C/C++排序算法实现 1、冒泡排序 2、简单选择排序 3、直接插入排序 4、希尔排序 5、堆排序 6、归并排序 7、快速排序
用C实现了排序算法中的插入排序、选择排序、冒泡排序、希尔排序、归并排序、快速排序、桶排序、基数排序
09-21
在这份文档中，我用C语言实现了排序算法的多种方法，包括插入排序、选择排序、冒泡排序、希尔排序、归并排序、快速排序、桶排序和基数排序。这些算法可以帮助我们对数据进行有效的排序和整理，以便更好地处理和分析...
基于比较的排序算法汇总 选择排序法 插入排序法 归并排序法 快速排序法 堆排序法 冒泡排序法 希尔排序法
01-15
堆排序
基于PHP的基本排序算法（快速排序、堆排序、基数排序等）
最新发布
03-27
排序算法 - 快速排序(Insert Sort) - 希尔排序(Shell Sort) - 冒泡排序(Bubble Sort) - 快速排序(Quick Sort) ...- 堆排序(Heap Sort) - 归并排序(Merge Sort) - 箱排序(Bin Sort) - 基数排序(Radix Sort)
Java各种排序算法汇总(冒泡,选择,归并,希尔及堆排序等)
09-03
主要介绍了Java各种排序算法,以大量实例形式汇总分析了Java常用的各种排序算法,包括冒泡排序、快速排序、堆排序、插入排序、希尔排序、选择排序、归并排序等,需要的朋友可以参考下
C#实现十种常用排序算法
11-11
C#实现十种常用排序算法，包含动图演示和文字描述以及生成随机数测试 十钟排序算法包括： 冒泡排序 堆排序 快速排序 选择排序 插入排序 希尔排序 归并排序 基数排序 计数排序 桶排序
100万个无序数排序算法的运行时间比较
m0_37673146的博客
11-20 4785
冒泡排序（时间复杂度N2，空间复杂度1） 依次比较数组相邻两个元素，将最大或最小元素放到后面，慢慢“浮”到数列的最后。 选择排序（时间复杂度N2，空间复杂度1） 首先找到数组最小元素，将它和数组的第一个元素交换位置。再次，在剩下的元素中找到最小的元素，将它与数组第二个元素交换，如此往复。 插入排序（时间复杂度介于N和N2之间，空间复杂度1） 将数组分为有序和无序两个部分，默认数组左变第一个元素是...
八种基本排序及其时间复杂度
热门推荐
yang03_26的博客
06-22 3万+
排序的例子（步骤）是方便理解用的，与程序无关，程序自动生成n个随机数排序并输出运算时间，如想输出排序后的数，请自行更改 1.冒泡排序 将相邻的两个数两两比较，每次外循环都将最大的数移到最后，每次内循环比较两个数，如果后一个数小于前一个数，两个数交换。 15 6 3422 8 12 30 6 15 228 12 30 34 6 158 12 2230 3...
排序算法c语言描述-快速排序随机化
xidajiancun
11-23 372
今天在做数据结构排序实验的时候，使用的快速排序。按理，我印象中快排是很高效的，不过，这次400w的数据，排了2659秒，有点意想不到，让我一度怀疑了算法是否写错了。 不过，认真分析，认真想想后， 也就释然了。 快排其实就是冒泡的升级版。 每次递归，把当前序列分成两部分，一个比枢纽元素大，一个比枢纽元素小。具体思想可以参见的之前写的一篇博客。 http://blog.csdn.net/h...
七大排序(插入排序,希尔排序,选择排序,堆排序,冒泡排序,快速排序,归并排序)
gp1330782530的博客
08-25 2942
七大排序(插入排序,希尔排序,选择排序,堆排序,冒泡排序,快速排序,归并排序) 1.插入排序:把待排序的记录按其关键码值的大小逐个插入到一个已经排好序的有序序列中，直到所有的记录插入完为止，得到一个新的有序序列 。 2.希尔排序:先选定一个整数，把待排序文件中所有记录分成gap/2个组，所有距离为的记录分在同一组内，并对每一组内的记录进行排序。然后取，重复上述分组和排序的工作。当到达gap...
直接插入排序，希尔排序，冒泡排序，快速排序，简单选择排序，堆排序，归并排序算法。
05-24
4. 快速排序：选定一个基准值，将数列分为左右两个部分，左边的元素都小于基准值，右边的元素都大于基准值，递归地对左右两个部分进行快速排序。时间复杂度为O(nlogn)。 5. 简单选择排序：从待排序的数列中选择最小...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值