几种常见排序算法实现

最新推荐文章于 2022-12-30 01:40:27 发布
最新推荐文章于 2022-12-30 01:40:27 发布
阅读量550 收藏
点赞数
分类专栏： 算法 文章标签： 排序算法 希尔排序 快速排序 冒泡排序 插入排序
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013189665/article/details/32733089
版权 
#include<iostream>
#include<time.h>
#include<windows.h>
#pragma comment(linker,"/subsystem:console")
using namespace std;
const int size=50000;
#pragma once
# define  rr 100000;
void InsertSort(int r[],int n)//插入排序
{
	 LARGE_INTEGER nFreq;
     LARGE_INTEGER nBeginTime;
     LARGE_INTEGER nEndTime;
     double time;
     QueryPerformanceFrequency(&nFreq);
     QueryPerformanceCounter(&nBeginTime);//记录开始执行时的时间
	int num1=0,num2=0;//记录移动次数和比较次数的参数
	for(int i=2;i<=n;i++)
	{
		int j;
		r[0]=r[i];//用哨兵记录待排序的数据
		for( j=i-1;r[0]<r[j];j--,num1++)
		{
			r[j+1]=r[j];
			num2=num2+3;
		}
		num1++;
		r[j+1]=r[0];//把数据放入合适的位置
		
	}
	QueryPerformanceCounter(&nEndTime);
    time=(double)(nEndTime.QuadPart-nBeginTime.QuadPart)/(double)nFreq.QuadPart*1000000;
	cout<<"排序后的数组为：";
	for(int k=1;k<=n;k++)
		cout<<r[k]<<"  ";
	cout<<endl;
	cout<<"比较次数为："<<num1<<endl;
	cout<<"移动次数为："<<num2<<endl;
    cout<<"执行时间: "<<time<<"uS"<<endl;
}
void ShellInsert(int r[],int n)//希尔排序
{
	 LARGE_INTEGER nFreq;
     LARGE_INTEGER nBeginTime;
     LARGE_INTEGER nEndTime;
     double time;
     QueryPerformanceFrequency(&nFreq);
     QueryPerformanceCounter(&nBeginTime);//记录开始执行时的时间
	int j;int num1=0,num2=0;
	for(int d=n/2;d>=1;d=d/2)//增量每次减少一半，最后增量为1
	{
		for(int i=d+1;i<=n;i++)//相隔d的元素进行比较
		{
			if(r[i]<r[i-d])
			{
				r[0]=r[i];
				for( j=i-d;j>0&&r[0]<r[j];j=j-d,num1++)
				{
					r[j+d]=r[j];
					num2=num2+3;
				}
				r[j+d]=r[0];
			}
			num1++;
		}
	}
	 QueryPerformanceCounter(&nEndTime);
     time=(double)(nEndTime.QuadPart-nBeginTime.QuadPart)/(double)nFreq.QuadPart*1000000;
	cout<<"排序后的数组为：";
	for(int k=1;k<=n;k++)
		cout<<r[k]<<"  ";
	cout<<endl;
	cout<<"比较次数为："<<num1<<endl;
	cout<<"移动次数为："<<num2<<endl;
	cout<<"执行时间: "<<time<<"uS"<<endl;
}
void BubbleSort(int r[],int n)//冒泡排序
{
	 LARGE_INTEGER nFreq;
     LARGE_INTEGER nBeginTime;
     LARGE_INTEGER nEndTime;
     double time;
     QueryPerformanceFrequency(&nFreq);
     QueryPerformanceCounter(&nBeginTime);//记录开始执行时的时间
	int pos=n;//pos记录最后一次比较的位置
	int num1=0,num2=0;
	while(pos!=0)
	{
		int bound=pos;
		pos=0;
		for(int i=1;i<bound;i++)
		{
			num1++;
			if(r[i]>r[i+1])
		   {
			   r[0]=r[i];r[i]=r[i+1];r[i+1]=r[0];
			   pos=i;num2=num2+3;
		   }
		}
	}
	QueryPerformanceCounter(&nEndTime);
    time=(double)(nEndTime.QuadPart-nBeginTime.QuadPart)/(double)nFreq.QuadPart*1000000;
	cout<<"排序后的数组为：";
	for(int k=1;k<=n;k++)
		cout<<r[k]<<"  ";
	cout<<endl;
	cout<<"比较次数为："<<num1<<endl;
	cout<<"移动次数为："<<num2<<endl;
	cout<<"执行时间: "<<time<<"uS"<<endl;
}
int Partion(int r[],int first,int end,int &num1,int &num2)//快速排序
{
	int i=first;int j=end;
	int pivot=r[i];//记录轴值
	while(i<j)
	{
		while((i<j)&&(r[j]>=pivot))//从右往左找比轴值小的元素
		{j--;num1++;}
		r[i]=r[j];if(i!=j)num2=num2+3;
		while((i<j)&&(r[i]<=pivot)&&num1++)//从左往右找比轴值大的元素
			i++;
		r[j]=r[i];if(i!=j)num2=num2+3;
	}
	r[i]=pivot;
	return i;
}
void Qsort(int r[],int i,int j,int &num1,int &num2)//快速排序
{
	if(i<j)
	{
		int pivotloc=Partion(r,i,j,num1,num2);
		Qsort(r,i,pivotloc-1,num1,num2);
		Qsort(r,pivotloc+1,j,num1,num2);
	}
}
void SelectSort(int r[],int n)//简单选择排序
{
	 LARGE_INTEGER nFreq;
     LARGE_INTEGER nBeginTime;
     LARGE_INTEGER nEndTime;
     double time;
     QueryPerformanceFrequency(&nFreq);
     QueryPerformanceCounter(&nBeginTime);//记录开始执行时的时间
	int num1=0,num2=0;
	for(int i=1;i<n;i++)
	{
		int index=i;//index记录最小值的位置
		for(int j=i+1;j<=n;j++,num1++)
			if(r[j]<r[index])
				index=j;
		if(index!=i)
		{
			num2=num2+3;
			r[0]=r[i];
			r[i]=r[index];
			r[index]=r[0];
		}
	}
	QueryPerformanceCounter(&nEndTime);
    time=(double)(nEndTime.QuadPart-nBeginTime.QuadPart)/(double)nFreq.QuadPart*1000000;
	cout<<"排序后的数组为：";
	for(int k=1;k<=n;k++)
		cout<<r[k]<<"  ";
	cout<<endl;
	cout<<"比较次数为："<<num1<<endl;
	cout<<"移动次数为："<<num2<<endl;
	cout<<"执行时间: "<<time<<"uS"<<endl;
}
void Sift(int r[],int k,int m,int &num1,int &num2)//希尔排序
{
	int i=k,j=2*i;
	while(j<=m)
	{
		num1++;
		if(j<m&&r[j]>r[j+1])
			j++;//找到左右孩子中较小者
		if(r[i]<r[j]){break;}
		else
		{
			num2=num2+3;
		    int num=r[i];
			r[i]=r[j];
			r[j]=num;
			i=j;
			j=2*i;
		}
	}
}
void HeapSort(int r[],int n)//堆排序
{
	 LARGE_INTEGER nFreq;
     LARGE_INTEGER nBeginTime;
     LARGE_INTEGER nEndTime;
     double time;
     QueryPerformanceFrequency(&nFreq);
     QueryPerformanceCounter(&nBeginTime);//记录开始执行时的时间
	int num1=0,num2=0;
	for(int i=n/2;i>=1;i--)
		Sift(r,i,n,num1,num2);//建立小根堆
	for(int j=1;j<n;j++)//每次输出堆顶元素再建堆
	{
		num2=num2+3;
		int num=r[1];
		r[1]=r[n-j+1];
		r[n-j+1]=num;
		Sift(r,1,n-j,num1,num2);
	}
    QueryPerformanceCounter(&nEndTime);
    time=(double)(nEndTime.QuadPart-nBeginTime.QuadPart)/(double)nFreq.QuadPart*1000000;
	cout<<"排序后的数组为：";
	for(int k=n;k>=1;k--)
		cout<<r[k]<<"  ";
	cout<<endl;
	cout<<"比较次数为："<<num1<<endl;
	cout<<"移动次数为："<<num2<<endl;
	cout<<"执行时间: "<<time<<"uS"<<endl;
}
void Merge(int r[],int r1[],int s,int m,int t,int &num1)
{
	int i=s;
	int j=m+1;
	int k=s;
	while(i<=m&&j<=t)
	{
		num1++;
		if(r[i]<r[j])
			r1[k++]=r[i++];//i和j中较小中进入r1数组
		else
			r1[k++]=r[j++];
	}
	if(i<=m)//没有排完部分继续存入数组r1后
		while(i<=m) r1[k++]=r[i++];
	if(j<=t)
		while(j<=t) r1[k++]=r[j++];
}
void MergePass(int r[],int r1[],int n,int h,int &num1)
{
	int i=1;
	while(i<=n-2*h-1)
	{
		Merge(r,r1,i,i+h-1,i+2*h-1,num1);
		i+=2*h;
	}
	if(i<n-h+1)
		Merge(r,r1,i,i+h-1,n,num1);//剩下两个序列中其中一个个数小于h
	else//只剩下一个序列时直接存入
		for(;i<=n;i++)
			r1[i]=r[i];
}
void MergeSort(int r[],int r1[],int n)//合并排序
{
	 LARGE_INTEGER nFreq;
     LARGE_INTEGER nBeginTime;
     LARGE_INTEGER nEndTime;
     double time;
     QueryPerformanceFrequency(&nFreq);
     QueryPerformanceCounter(&nBeginTime);//记录开始执行时的时间
	int num1=0;
	int h=1;
	while(h<n)
	{
		MergePass(r,r1,n,h,num1);
		h=h*2;//h每次倍增
		for(int i=1;i<=n;i++)
			r[i]=r1[i];
	}
	QueryPerformanceCounter(&nEndTime);
    time=(double)(nEndTime.QuadPart-nBeginTime.QuadPart)/(double)nFreq.QuadPart*1000000;
	cout<<"排序后的数组为：";
	for(int k=1;k<=n;k++)
		cout<<r[k]<<"  ";
	cout<<endl;
	cout<<"比较次数为："<<num1<<endl;
	cout<<"移动次数为："<<0<<endl;
	cout<<"执行时间: "<<time<<"uS"<<endl;
}

void menu(int r[],int n)
{
	int b[100];int x;
	int d[11];
	for(int e=1;e<=10;e++)
		d[e]=r[e];
	system("cls");
    cout<<"\t\t---------------------------菜单-----------------------------|\n";
	cout<<"\t\t------------------------------------------------------------|\n";
	cout<<"\t\t|                                                           |\n";
	cout<<"\t\t|☆☆☆☆☆              主菜单                   ☆☆☆☆☆|\n";
	cout<<"\t\t|☆☆☆☆☆  1.   插入排序                        ☆☆☆☆☆|\n";
	cout<<"\t\t|☆☆☆☆☆  2.   希尔排序                        ☆☆☆☆☆|\n";
	cout<<"\t\t|☆☆☆☆☆  3.   冒泡排序                        ☆☆☆☆☆|\n";
	cout<<"\t\t|☆☆☆☆☆  4.   快速排序                        ☆☆☆☆☆|\n";
	cout<<"\t\t|☆☆☆☆☆  5.   简单选择排序                    ☆☆☆☆☆|\n";
	cout<<"\t\t|☆☆☆☆☆  6.   堆排序                          ☆☆☆☆☆|\n";
	cout<<"\t\t|☆☆☆☆☆  7.   归并排序                        ☆☆☆☆☆|\n";
	cout<<"\t\t|☆☆☆☆☆  8.   退出                            ☆☆☆☆☆|\n";
	cout<<"\t\t-------------------------------------------------------------\n";

	cout<<"\t\t请输入你的选择:";
	while(true)
	{
    cin>>x;
	if(!(x>=1&&x<=8))
	{
		cout<<"请你重新输入你的选择：";
		continue;
	}
	else break;
	}
	int num1=0,num2=0;
	switch(x)
	{
	case 1:
		{	system("cls");
		InsertSort(r,n);
		cout<<"返回上一层请按1:";
		int a1;
		cin>>a1;
		if(a1==1)
			menu(d,n);
		break;}
	case 2:
	{	system("cls");
		ShellInsert(r,n);
		cout<<"返回上一层请按1:";
		int a2;
		cin>>a2;
		if(a2==1)
			menu(d,n);
		break;}
	case 3:
	{		system("cls");
        BubbleSort(r,n);
		cout<<"返回上一层请按1:";
		int a3;
		cin>>a3;
		if(a3==1)
			menu(d,n);
		break;}
	case 4:
		{	system("cls");
	    LARGE_INTEGER nFreq;
        LARGE_INTEGER nBeginTime;
        LARGE_INTEGER nEndTime;
        double time;
        QueryPerformanceFrequency(&nFreq);
        QueryPerformanceCounter(&nBeginTime);//记录开始执行时的时间
	    Qsort(r,1,n,num1,num2);
		QueryPerformanceCounter(&nEndTime);
        time=(double)(nEndTime.QuadPart-nBeginTime.QuadPart)/(double)nFreq.QuadPart*1000000;
		cout<<"排序后的数组为：";
	    for(int k=1;k<=n;k++)
		    cout<<r[k]<<"  ";
	    cout<<endl;
		cout<<"比较次数为："<<num1<<endl;
	    cout<<"移动次数为："<<num2<<endl;
		cout<<"执行时间: "<<time<<"uS"<<endl;
		cout<<"返回上一层请按1:";
		int a4;
		cin>>a4;
		if(a4==1)
			menu(d,n);
		break;}
	 case 5:
		 {system("cls");
        SelectSort(r,n);
		cout<<"返回上一层请按1:";
		int a5;
		cin>>a5;
		if(a5==1)
			menu(d,n);
		break;}
	  case 6:
		  {	system("cls");
        HeapSort(r,n);
		cout<<"返回上一层请按1:";
		int a6;
		cin>>a6;
		if(a6==1)
			menu(d,n);
		break;}
	  case 7:
		  {	system("cls");
        MergeSort(r,b,n);
		cout<<"返回上一层请按1:";
		int a7;
		cin>>a7;
		if(a7==1)
			menu(d,n);
		break;}
	  case 8:break;
	}
}
void put(int m)
{  
	switch(m)
	{
	case 1:
		{
	      cout<<"要进行几个数的排序：";
	      int n;
	      cin>>n;
	      int *a=new int [n+1];
	      cout<<"请输入需要排序的"<<n<<"个数：";
	      for(int k=1;k<=n;k++)
	   {
          cin>>a[k];
	    }
	    menu(a,n);
	   delete []a;
	     break;
		}
	 case 2:
		{ 
			
		    cout<<"将产生"<<size<<"个随机数"<<endl;
		    int *b=new int  [size+1];
		    for( int i=1;i<=size;i++)
			    b[i]=rand()% rr;
		     menu(b,size);
		    delete []b;
		    break;
		}
	
}
}
int main()
{
	 int c;
	cout<<"键盘输入数据-1"<<endl;
	cout<<"产生随机数-2"<<endl;
	cin>>c;
	if(c!=1&&c!=2)
	{
		cout<<"键盘输入数据-1"<<endl;
	    cout<<"产生随机数-2"<<endl;
		cin>>c;
	}
	put(c);
	return 0;

}
供大家学习
鬼步
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
几种常见的排序算法及其实现
11-20
排序算法是计算机科学中最基本且常见的算法之一。排序的目标是将一组数据按照升序或降序的方式进行排列。在实际编程中，选择适当的排序算法对于提高程序性能和效率至关重要...下面简要介绍几种常见的排序算法及其实现。
常见的排序算法实现
zsxfa的博客
01-10 543
排序算法排序的分类冒泡排序 排序的分类 冒泡排序 冒泡排序（Bubble Sorting）的基本思想是：通过对待排序序列从前向后（从下标较小的元素开始）,依次比较相邻元素的值，若发现逆序则交换，使值较大的元素逐渐从前移向后部，就象水底下的气泡一样逐渐向上冒。 优化： 因为排序的过程中，各元素不断接近自己的位置，如果一趟比较下来没有进行过交换，就说明序列有序，因此要在排序过程中设置一个标志 flag 判断元素是否进行过交换。从而减少不必要的比较。 // 将冒泡排序算法封装成一个方法 public sta
【算法】十种排序算法及其实现
qq_40900926的博客
11-01 178
1，按照时间复杂度分类 O(n^2)：冒泡排序、选择排序、插入排序 O(n^2~nlogn)：希尔排序 O(nlogn)：快速排序（不稳定）、堆排序（稳定）、归并排序（稳定，需要额外空间） O(n)：基数排序、计数排序、桶排序 2，快速排序 分为单指针算法和双指针算法，我这里主推双指针，比较简洁； 有一点很重要，快排和归排都属于分而治之的算法，前者重分轻合，后者重合请分； 以下代码，是快速排序的实现，供参考； package _算法._查找与排序2; import org.juni
排序算法详解（八大排序算法的实现）
大米饭的记录册
12-30 1271
文章中讲解了直接插入排序、希尔排序、直接选择排序、堆排序、冒泡排序、快速排序、归并排序及计数排序这八种常见排序算法的实现，分析了每种排序算法的复杂度，并对每种排序算法的特性做了基本总结。
十大排序算法总结与实现
jaredray的博客
03-31 1229
十大排序算法
常见排序算法基本原理及实现（快排，归并，堆排，直接插入.....）
weixin_47792933的博客
12-05 3273
文章目录常见排序算法总览1.概念1.1 排序1.2 稳定性（重要）2.插入排序2.1直接插入排序-原理2.2代码实现2.3性能分析3.希尔排序3.1 原理3.堆排序3.1原理 常见排序算法总览 1.概念 1.1 排序 排序就是使待排序序列，按照其中的某个或某些关键字的大小（以什么作为比较基准），递增或递减的排列起来的操作。平时如果提到排序，通常指的是排升序（非降序）。通常意义上的排序，都是指的原地排序(in place sort)。 1.2 稳定性（重要） 两个相等的数据，如果经过排序后，排序算法能保证其
几种常见排序算法的实现
07-29
常见的几种排序算法的实现：选择排序、插入排序、冒泡排序、希尔排序、快速排序、归并排序。包括实现与局测试。
Java实现几种常见排序算法代码
09-05
排序(Sorting) 是计算机程序设计中的一种重要操作，它的功能是将一个数据元素（或记录）的任意序列，重新排列成一个关键字有序的序列
几种常用排序算法实现及耗时比较
03-13
包括冒泡排序，选择排序，插入排序，希尔排序，快速排序等常用排序算法的实现并耗时比较
实现所有经典排序算法汇总
05-02
据传为经典排序算法。 选择排序 冒泡排序 快速排序 插入排序 希尔排序 归并排序 基数排序 计数排序 小根堆排序
常见六种排序算法的实现
10-11
1、插入排序 2、shell排序 3、堆排序 4、冒泡排序 5、快速排序 6、归并排序
排序算法的实现
02-10
C语言实现八种排序算法，C语言实现八种排序算法，C语言实现八种排序算法，
【数据结构】常见八大排序的实现
m0_51064412的博客
07-27 900
文章目录一. 排序相关的概念二. 常见排序算法的实现1. 直接插入排序2. 希尔排序 一. 排序相关的概念 排序概念 所谓排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。 排序的稳定性 在未排序前，a下标对应的值和b下标对应的值相等（a < b），排序后如果这两个位置的相等值仍然保持和排序前一样的前后顺序则说明该排序稳定。 内部排序 数据元素全部放在内存中的完成的排序。 外部排序 数据元素太多不能同时放在内存中完成排序，只能放到文件或磁盘中（存在文件或磁盘中就不能
几个常用排序算法的实现
风行天下
12-03 209
import java.util.Arrays; public class SortTest { private static int[] nums = {5,2,9,4,0,7,3,8,6,1}; public static void main(String[] args) { System.out.println("nums:"+Arrays.toString(nums)); // int[] result = maoPaoSort(nums); //
Java算法——排序算法
Huntermax LC的博客
01-31 254
文章目录排序的分类冒泡排序(Bubble Sorting)选择排序(Select Sorting)插入排序(Insert Sorting) 排序的分类 内部排序 将需要处理的所有数据都加载到内部存储器中进行排序。 外部排序 数据量过大，无法全部加载到内存中，需要借助外部存储进行排序。 内部排序分类： 插入排序（直接插入排序、希尔排序） 选择排序（简单选择排序、堆排序） 交换排序（冒泡排序、...
经典排序算法及其Python实现
Kaiyuan_sjtu的博客
02-15 1171
写在前面 前面学习了几种典型的数据结构，当然数据结构和算法是密不可分的，算法作为程序的一个重要部分也是在求职面试中屡问不爽的考点，最近我们就来整理一下一些经典的算法，包括排序、查找、图、动态规划等等。这一篇就从最常见的排序算法开始。 1.排序及其分类 所谓排序就是将一组无序的记录序列调整为有序的记录序列。 选择排序：主要包括简单选择排序和堆排序 插入排序：简单插入排序、希尔排序 交换排...
C#实现几种排序算法
最新发布
05-26
以下是C#实现的几种常见排序算法示例： 1. 冒泡排序 ```csharp static void BubbleSort(int[] arr) { int len = arr.Length; for (int i = 0; i ; i++) { for (int j = 0; j ; j++) { if (arr[j] > arr[j + ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值