各种排序算法时间效率，数据移动次数以及比较次数对比【数据结构】

最新推荐文章于 2024-08-19 15:21:18 发布
最新推荐文章于 2024-08-19 15:21:18 发布
阅读量1.9w 收藏 137
点赞数 25
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41333844/article/details/84728307
版权 
#include<bits/stdc++.h>
using namespace std;
#define MAXN 100000000
int maxn;
int N[MAXN+5];
//        Compare 比较次数          Move 移动次数 
long long InsertMove,InsertComp,BInsertMove,BInsertComp,QComp,QMove,BubbleComp,BubbleMove,ShellComp,ShellMove;

typedef struct{
    int key;
    //int m;
}ElemType;

typedef struct{
    int len;
    ElemType *r;//*r 与 r[MAXNSIZE]有区别
}sq;

void CreateNum(){
    srand((unsigned)time(NULL));
    for(int i=1;i<=maxn;i++){
        N[i]=rand()%MAXN;
    }
}

sq init(){
    sq L;
    L.len=maxn;
    L.r=new ElemType[maxn+1];
    for(int i=1;i<=maxn;i++){
        L.r[i].key=N[i];
    }
    return L;
}

void InsertSort(sq &L){
    int j;
    for(int i=2;i<=L.len;i++){
    	InsertComp++;
        if(L.r[i].key<L.r[i-1].key){
            L.r[0].key=L.r[i].key;
            InsertMove++;
            for(j=i-1;L.r[j].key>L.r[0].key;j--,InsertComp++){
                L.r[j+1].key=L.r[j].key;
                InsertMove++;
            }
            L.r[j+1].key=L.r[0].key;
            InsertMove++;
        }
    }
}

void BInsertSort(sq &L){
    int j,l,r,temp;
    for(int i=2;i<=L.len;i++){
        temp=L.r[i].key;
        l=1,r=i-1;
        while(l<=r){
            int m=(l+r)/2;
            if(temp<L.r[m].key) r=m-1;
            else l=m+1;
            BInsertComp++;
        }
        for(j=i;j>=l+1;j--) {
			L.r[j].key=L.r[j-1].key;//L.r[j]=L.r[j-1];
			BInsertMove++;
		}
        L.r[l].key=temp;
        BInsertMove++;
    }
}

void ShellInsert(sq &L,int dk){
	int i,j;
	for(i=dk+1;i<=L.len;i++){
		ShellComp++;
		if(L.r[i].key<L.r[i-dk].key){
			L.r[0]=L.r[i];
			ShellMove++;
			for(j=i-dk;j>0&&L.r[0].key<L.r[j].key;j-=dk,ShellComp++){
				L.r[j+dk]=L.r[j];
				ShellMove++;
			}		
			L.r[j+dk]=L.r[0];
			ShellMove++;
		}
	}
}

void ShellSort(sq &L,int t){//5 3 1 -> t=3   7 5 3 1 -> t=4
	int dt[100];
	for(int j=0;j<t;j++){ 
	/*
	3 0 5 5
	3 1 3 5
	3 2 1 5
	*/
		dt[j]=-2*j+t+2;
	}
 	for(int i=0;i<t;i++)
 		ShellInsert(L,dt[i]);
}

int Partition(sq &L,int low,int high){
	//对顺序表L中的子表r[low..high]进行一趟排序，返回枢轴位置
	int pivotkey;
	L.r[0]=L.r[low];                    	//用子表的第一个记录做枢轴记录
	pivotkey=L.r[low].key;		   			//枢轴记录关键字保存在pivotkey中
	while(low<high)	{										//从表的两端交替地向中间扫描
		while(low<high&&L.r[high].key>=pivotkey) --high,QComp++;
		L.r[low]=L.r[high],QMove++;				//将比枢轴记录小的记录移到低端
		while(low<high&&L.r[low].key<=pivotkey) ++low,QComp++;
		L.r[high]=L.r[low],QMove++;					//将比枢轴记录大的记录移到高端
		
	}//while
	L.r[low]=L.r[0];						//枢轴记录到位
	return  low;							//返回枢轴位置
}//Partition

void QSort(sq &L,int low,int high){	//调用前置初值：low=1; high=L.length;
    //对顺序表L中的子序列L.r[low..high]做快速排序
	int pivotloc;
    if(low<high){										//长度大于1
       pivotloc=Partition(L,low,high); 		//将L.r[low..high]一分为二，pivotloc是枢轴位置
       QSort(L,low,pivotloc-1);				//对左子表递归排序
       QSort(L,pivotloc+1,high);        	//对右子表递归排序
	}
}											//QSort

void QuickSort(sq &L){
	//对顺序表L做快速排序
   QSort(L,1,L.len);
}											//QuickSort

void BubbleSort(sq &L){
	for(int i=1;i<L.len;i++){
		for(int j=1;j<=L.len-i;j++){
			BubbleComp++;
			if(L.r[j+1].key<L.r[j].key) {
				swap(L.r[j+1],L.r[j]);
				BubbleMove+=2;
			}
		}
	}	
}

void show(sq L){
    for(int i=1;i<=L.len;i++)
        cout<<L.r[i].key<<' ';
    puts("");
}

int main(){
	int temp=100;
    for(int i=1;i<=5;i++){//100~1000000
    	InsertMove=0,InsertComp=0,BInsertMove=0,BInsertComp=0,QComp=0,QMove=0,BubbleComp=0,BubbleMove=0,ShellComp=0,ShellMove=0; 
    	maxn=temp;
    	cout<<"当前数量级是"<<temp<<endl;  
    	CreateNum();//生成一组随机数
    	sq L=init();
        double s=clock();
        InsertSort(L);
        double e=clock();
        cout<<"直接插入排序时间是"<<e-s<<"ms"<<endl;
        cout<<"直接插入移动次数是"<<InsertMove<<endl;
        cout<<"直接插入比较次数是"<<InsertComp<<endl<<endl;
        
        L=init();
        s=clock();
        BInsertSort(L);
        e=clock();
        cout<<"二分插入排序时间是"<<e-s<<"ms"<<endl;
        cout<<"二分插入移动次数是"<<BInsertMove<<endl;
        cout<<"二分插入比较次数是"<<BInsertComp<<endl<<endl;
        
        L=init();
        s=clock();
        QuickSort(L);
        e=clock();
        cout<<"快排时间是"<<e-s<<"ms"<<endl;
        cout<<"快排移动次数是"<<QMove<<endl;
        cout<<"快排比较次数是"<<QComp<<endl<<endl;
        
        L=init();
    	s=clock();
		ShellSort(L,3);// dt 5 3 1 -> 3
        e=clock();
        cout<<"希尔排序时间是"<<e-s<<"ms"<<endl;
        cout<<"希尔排序移动次数是"<<ShellMove<<endl;
        cout<<"希尔排序比较次数是"<<ShellComp<<endl<<endl;
        
        L=init();
    	s=clock();
        BubbleSort(L);
        e=clock();
        cout<<"冒泡排序时间是"<<e-s<<"ms"<<endl;
        cout<<"冒泡排序移动次数是"<<BubbleMove<<endl;
        cout<<"冒泡排序比较次数是"<<BubbleComp<<endl<<endl;
        
        temp*=10;
        cout<<"------------------------------------------"<<endl;
	}
    return 0;
}

 结果输出到文件中

#include<bits/stdc++.h>
using namespace std;
#define MAXN 100000000
int maxn;
int N[MAXN+5];
//        Compare 比较次数          Move 移动次数
long long InsertMove,InsertComp,BInsertMove,BInsertComp,QComp,QMove,BubbleComp,BubbleMove,ShellComp,ShellMove;
 
typedef struct{
    int key;
    //int m;
}ElemType;
 
typedef struct{
    int len;
    ElemType *r;//*r 与 r[MAXNSIZE]有区别
}sq;
 
void CreateNum(){
    srand((unsigned)time(NULL));
    for(int i=1;i<=maxn;i++){
        N[i]=rand()%MAXN;
    }
}
 
sq init(){
    sq L;
    L.len=maxn;
    L.r=new ElemType[maxn+1];
    for(int i=1;i<=maxn;i++){
        L.r[i].key=N[i];
    }
    return L;
}
 
void InsertSort(sq &L){
    int j;
    for(int i=2;i<=L.len;i++){
    	InsertComp++;
        if(L.r[i].key<L.r[i-1].key){
            L.r[0].key=L.r[i].key;
            InsertMove++;
            for(j=i-1;L.r[j].key>L.r[0].key;j--,InsertComp++){
                L.r[j+1].key=L.r[j].key;
                InsertMove++;
            }
            L.r[j+1].key=L.r[0].key;
            InsertMove++;
        }
    }
}
 
void BInsertSort(sq &L){
    int j,l,r,temp;
    for(int i=2;i<=L.len;i++){
        temp=L.r[i].key;
        l=1,r=i-1;
        while(l<=r){
            int m=(l+r)/2;
            if(temp<L.r[m].key) r=m-1;
            else l=m+1;
            BInsertComp++;
        }
        for(j=i;j>=l+1;j--) {
			L.r[j].key=L.r[j-1].key;//L.r[j]=L.r[j-1];
			BInsertMove++;
		}
        L.r[l].key=temp;
        BInsertMove++;
    }
}
 
void ShellInsert(sq &L,int dk){
	int i,j;
	for(i=dk+1;i<=L.len;i++){
		ShellComp++;
		if(L.r[i].key<L.r[i-dk].key){
			L.r[0]=L.r[i];
			ShellMove++;
			for(j=i-dk;j>0&&L.r[0].key<L.r[j].key;j-=dk,ShellComp++){
				L.r[j+dk]=L.r[j];
				ShellMove++;
			}
			L.r[j+dk]=L.r[0];
			ShellMove++;
		}
	}
}
 
void ShellSort(sq &L,int t){//5 3 1 -> t=3   7 5 3 1 -> t=4
	int dt[100];
	for(int j=0;j<t;j++){
	/*
	3 0 5 5
	3 1 3 5
	3 2 1 5
	*/
		dt[j]=-2*j+t+2;
	}
 	for(int i=0;i<t;i++)
 		ShellInsert(L,dt[i]);
}
 
int Partition(sq &L,int low,int high){
	//对顺序表L中的子表r[low..high]进行一趟排序，返回枢轴位置
	int pivotkey;
	L.r[0]=L.r[low];                    	//用子表的第一个记录做枢轴记录
	pivotkey=L.r[low].key;		   			//枢轴记录关键字保存在pivotkey中
	while(low<high)	{										//从表的两端交替地向中间扫描
		while(low<high&&L.r[high].key>=pivotkey) --high,QComp++;
		L.r[low]=L.r[high],QMove++;				//将比枢轴记录小的记录移到低端
		while(low<high&&L.r[low].key<=pivotkey) ++low,QComp++;
		L.r[high]=L.r[low],QMove++;					//将比枢轴记录大的记录移到高端
 
	}//while
	L.r[low]=L.r[0];						//枢轴记录到位
	return  low;							//返回枢轴位置
}//Partition
 
void QSort(sq &L,int low,int high){	//调用前置初值：low=1; high=L.length;
    //对顺序表L中的子序列L.r[low..high]做快速排序
	int pivotloc;
    if(low<high){										//长度大于1
       pivotloc=Partition(L,low,high); 		//将L.r[low..high]一分为二，pivotloc是枢轴位置
       QSort(L,low,pivotloc-1);				//对左子表递归排序
       QSort(L,pivotloc+1,high);        	//对右子表递归排序
	}
}											//QSort
 
void QuickSort(sq &L){
	//对顺序表L做快速排序
   QSort(L,1,L.len);
}											//QuickSort
 
void BubbleSort(sq &L){
	for(int i=1;i<L.len;i++){
		for(int j=1;j<=L.len-i;j++){
			BubbleComp++;
			if(L.r[j+1].key<L.r[j].key) {
				swap(L.r[j+1],L.r[j]);
				BubbleMove+=2;
			}
		}
	}
}
 
void show(sq L){
    for(int i=1;i<=L.len;i++)
        cout<<L.r[i].key<<' ';
    puts("");
}
 
int main(){
    ofstream fp;
    //fp.open("C:\\Users\\Answer\\Desktop\\排序算法数据统计.txt",ios_base::app);
    fp.open("C:\\Users\\Answer\\Desktop\\排序算法数据统计.txt");
 
	int temp=100;
    for(int i=1;i<=5;i++){//100~1000000
    	InsertMove=0,InsertComp=0,BInsertMove=0,BInsertComp=0,QComp=0,QMove=0,BubbleComp=0,BubbleMove=0,ShellComp=0,ShellMove=0;
    	maxn=temp;
    	fp<<"当前数量级是"<<temp<<endl;
    	CreateNum();//生成一组随机数
    	sq L=init();
        double s=clock();
        InsertSort(L);
        double e=clock();
        fp<<"直接插入排序时间是"<<e-s<<"ms"<<endl;
        fp<<"直接插入移动次数是"<<InsertMove<<endl;
        fp<<"直接插入比较次数是"<<InsertComp<<endl<<endl;
 
        L=init();
        s=clock();
        BInsertSort(L);
        e=clock();
        fp<<"二分插入排序时间是"<<e-s<<"ms"<<endl;
        fp<<"二分插入移动次数是"<<BInsertMove<<endl;
        fp<<"二分插入比较次数是"<<BInsertComp<<endl<<endl;
 
        L=init();
        s=clock();
        QuickSort(L);
        e=clock();
        fp<<"快排时间是"<<e-s<<"ms"<<endl;
        fp<<"快排移动次数是"<<QMove<<endl;
        fp<<"快排比较次数是"<<QComp<<endl<<endl;
 
        L=init();
    	s=clock();
		ShellSort(L,3);// dt 5 3 1 -> 3
        e=clock();
        fp<<"希尔排序时间是"<<e-s<<"ms"<<endl;
        fp<<"希尔排序移动次数是"<<ShellMove<<endl;
        fp<<"希尔排序比较次数是"<<ShellComp<<endl<<endl;
 
        L=init();
    	s=clock();
        BubbleSort(L);
        e=clock();
        fp<<"冒泡排序时间是"<<e-s<<"ms"<<endl;
        fp<<"冒泡排序移动次数是"<<BubbleMove<<endl;
        fp<<"冒泡排序比较次数是"<<BubbleComp<<endl<<endl;
 
        temp*=10;
        fp<<"------------------------------------------"<<endl;
	}
    return 0;
}

 

cugzyc
关注
专栏目录
排序算法
qq_36779496的博客
08-24 695
       排序算法的性能主要受三个方面影响： 1. 时间性能    主要设计两种操作：比较和移动。高效的排序算法应该尽可能少的比较次数和尽可能少的移动次数。 2.辅助空间   即算法的空间复杂度 3.算法的复杂性  指算法本身的复杂性，过于复杂也会影响排序性能。 除此之外，排序算法有时还会考虑其稳定性。这是指排序元素相等时，不改变其先后顺序即为稳定。   排序用到的数组元素交换函数...
设计一个测试程序比较几种内部排序算法的关键字比较次数和移动次数以取得直观感受。
12-26
设计一个测试程序比较几种内部排序算法的关键字比较次数和移动次数以取得直观感受。
数据结构综合课设排序算法时间.docx
03-26
[基本要求] 直接插入排序、希尔排序、直接选择排序、堆排序、起泡排序、快速排序。 （1）随机生成一组待排序数据，个数不少于100个； （2）比较各种排序算法对同一组数据排序所需要的关键字比较次数和关键字移动次数，至少使用5组数据进行比较； （3）对比较结果进行简单分析。
c++ 数据结构6种排序算法及关键词比较次数移动次数统计
03-12
冒泡排序 快速排序 直接插入排序 简单选择排序 希尔排序 堆排序算法等对正序随机数，逆序随机数，无序随机数进行排序，并统计关键词比较次数 记录移动次数的c++代码
常见的排序算法汇总（详解篇）
最新发布
m0_73634434的博客
08-19 2461
所谓排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。稳定性 ：假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的相对次序保持不变，即在原序列中， r[i]=r[j] ，且 r[i] 在 r[j] 之前，而在排序后的序列中， r[i] 仍在 r[j] 之前，则称这种排序算法是稳定的；否则称为不稳定的。数据元素全部放在内存中的排序。数据元素太多不能同时放在内存中，根据排序过程的要求不能在内外存之间移动数据的排序。
各种排序算法的比较次数
热门推荐
不舍驽马
08-08 3万+
借助比较的排序每次比较贡献O(1)的复杂度 插入排序   最少n-1 最多n(n-1)/2 冒泡排序   最少n-1 最多n(n-1)/2 选择排序   n(n-1)/2 快速排序    int partition(int *arr , int low , int high)   {       int pivo = arr[low];       
python实现八大排序算法及性能分析（比较次数与移动次数分析）
weixin_47042983的博客
06-14 2318
Libaray import numpy as np import pandas as pd from tqdm import tqdm 数据生成 test_50000 = np.random.randint(0, 100000, (50000)) print("test_50000, len:%d, test_50000[1]=%d"%(len(test_50000),test_50000[1])) test_100000 = np.random.randint(0, 200000, (10000
深入学习排序算法之稳定性、比较次数、交换次数探讨
dreamer2020的专栏
05-11 2万+
在学习排序算法时，出于效率考虑，经常容易看到算法的稳定性、比较次数及交换次数研究。特别是考试或者公司笔试题，经常出现这样的题目。由于排序算法有很多种，平时提出大家才能说出个大概，但真要考查这些细节，估计很多人都说不准确。博主下决心写此文章，彻底探查清楚这些问题，与大家共享之。         首先说明稳定性是指相同元素在排序后相对位置保持不变。个人感觉稳定性的含义在于更广泛情形下，排序元素通常具
数据结构课程设计 比较几种内部排序算法的关键字比较次数和移动次数以取得直观感受
06-18
设计一个测试程序比较几种内部排序算法的关键字比较次数和移动次数以取得直观感受
算法-排序（3）基础排序算法比较
04-16 888
排序的时间开销可用算法执行中的数据比较次数和数据移动次数来衡量。 不稳定的排序方法往往是按照一定的间隔移动或交换记录对象的位置，从而可能导致具有相等排序码的不同对象的前后相对位置在排序前后颠倒过来。 稳定的排序方法往往在相邻的数据对象间比较排序码，如果发生逆序才交换，具有相等排序码的不同对象在排序前后不会颠倒。 一、起泡排序算法 1.基础起泡排序算法 n-1次起泡，第i次起泡从...
数据结构课程设计报告各种排序算法性能比较.doc
05-06
数据结构课程设计报告各种排序算法性能比较 本报告对各种排序算法的性能进行了比较，涵盖直接插入排序、直接选择排序、冒泡排序、Shell 排序、快速排序、堆排序等六类排序算法。通过对不同测试数据的测试比较，记录...
各种排序算法比较
11-20
常用的排序算法进行比较和总结，以及如何排序的思想
六种排序算法性能比较
03-31
使用java描述了常见的六种排序算法，分别是直接插入排序，二分插入排序，选择排序，冒泡排序，快速排序以及二路归并排序，同时在不同的基数下能够查看各种排序算法的运行时间，通过比较发现当数组个数很大时，二路归并排序所耗费的时间最少，不过二路归并排序需要额外的内存空间。
各种排序算法的比较程序
05-23
里面整合了多种算法中的七种常用的排序算法的，可以一次比较两个或者多个算法的效率，界面人性化，很好用
数据结构实验：八个排序算法的实现与比较
11-07
所谓排序(Sorting)，就是对数据元素集合建立某种有序排列的过程...所以将用不同的数据集（数据的不同规模、初始数据的各种排列）进行实验数据对比，对比比较次数，移动记录个数，运行时间等，并根据实验结果得出结论。
内部排序算法性能对比：随机数据下的关键字比较与移动次数研究
在概要设计部分，详细描述了每种排序算法的实现方法，例如，顺序表作为数据结构，使用`SqList`类型，包含了元素数组`elem`、长度`length`和两个用于记录比较次数和移动次数的整型变量`a`和`b`。每个排序函数都以顺序...
几种排序算法比较
卑鄙的我
12-27 8750
前言 排序是按照关键字的非递减或非递增顺序对一组记录重新进行排列的操作，是对无规律的一组序列转化为递增或递减的操作。 排序的稳定性： 当排序记录中的关键字都部相同时，则任何一个记录的无序序列经过排序后得到的结果都唯一，反之，若存在两个或多个关键字相同时，则得到的结果可能不唯一。 假设Ki=Kj且排序前Ki在Kj之前，排序后Ki仍然在kj之前，则称排序时稳定...
七种机器内部排序的原理与C语言实现，并计算它们的比较次数与移动次数。
weixin_30666943的博客
07-06 2114
内部排序是指待排序列完全存放在内存中所进行的排序过程，适合不太大的元素序列。 排序是计算机程序设计中的一种重要操作，其功能是对一个数据元素集合或序列重新排列成一个按数据元素某个相知有序的序列。排序分为两类：内排序和外排序。 其中快速排序的是目前排序方法中被认为是最好的方法。 内部排序方法： 1.插入排序（直接插入排序）； 2.快速排序； 3.选择排序（简单选择排序）； 4...
归并排序的比较次数和移动次数_453. 最小移动次数使数组元素相等
weixin_32900811的博客
01-12 1217
给定一个长度为 n 的非空整数数组，找到让数组所有元素相等的最小移动次数。每次移动将会使 n - 1 个元素增加 1。 示例: 输入: [1,2,3] 输出: 3 解释: 只需要3次移动（注意每次移动会增加两个元素的值）： [1,2,3] => [2,3,3] => [3,4,3] => [4,4,4] 算法 该方法基于以下思路：将除了一个元素之外的全部元...
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值