八大排序所花时间测试序列（线性复杂度居然干不过log复杂度？）（采用的C++，结构体排序）

最新推荐文章于 2022-08-21 21:09:11 发布
最新推荐文章于 2022-08-21 21:09:11 发布
阅读量1.1k 收藏
点赞数 7
分类专栏： 数据结构与算法 OOP 文章标签： C++ 排序算法 性能测试 字符串排序 时间复杂度
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zr1008/article/details/115357811
版权

首先是测试前准备

整体思路：生成1000个随机的字符串，如果字符串相同长度，就按字典序从小到大，否则，按照字符串长度从小到大排序，对于每一种方法，都用clock（）函数记录总体时间，最后进行汇总

首先是代码准备：

#include<iostream>
#include<string>
#include<vector>
#include<time.h>
#include<algorithm>
#include<map>
#include "排序方法大全.h"
using namespace std;
const int MAXN = 1000;
const int MAXW = 100;
//随机给一组串长1-100的随机小写字母字符串，先按照串长排序，如果串长相同，则按照字典序排序
#pragma once

bool cmp(String s1, String s2);

void buddle_sort(vector<String> s);

void select_sort(vector<String> s);

void insert_sort(vector<String> s);

void insert_sort(vector<String>& s, int start, int space);

void Shell_sort(vector<String> s);

void quick_sort(vector<String>& s, int start, int end, String key);

void quick(vector<String> s);

void merge(vector<String>& s, int s1, int len1, int s2, int len2);

void merge_sort(vector<String>& s, int start, int end);

void merge_sort(vector<String> s);

void heap_sort(vector<String>& s);

void bucket_sort(vector<String>& s);

void divide_bucket(vector<String> s);

int main()
{
	//随机数种子替换
	srand(time(0));
	vector<String> s(MAXN);
	//测试冒泡排序
	buddle_sort(s);
	//测试选择排序
	select_sort(s);
	//测试插入排序
	insert_sort(s);
	//测试希尔排序(分治法）
	Shell_sort(s);
	//测试快速排序(递归,二分)
	quick(s);
	//测试归并排序
	merge_sort(s);
	//测试堆排序
	heap_sort(s);
	//测试桶排序
	divide_bucket(s);
	//测试STL：sort
	Sort(s);
	system("pause");

}

构造String类，它是由string字符串和一个int计算长度的构成。
String构造函数里面随机赋予了长度在1-100的随机字符的字符串给str
再重构3个运算符 > < ==

struct String
{
	int length;
	string str;
	//冒泡排序
	String()
	{

		length = rand() % 100 + 1;
		for (int i = 0; i <= length - 1; i++)
		{
			char c = rand() % 26 + 'a';
			char s[2] = { rand() % 26 + 'a' };
			str.append(s);
		}
	}
	String(int x)
	{
		length = 0;
		str = "\0";
	}
	bool operator>(String str)
	{
		return (this->length == str.length) ? (this->str > str.str) : (this->length > str.length);
	}
	bool operator<(String str)
	{
		return !((this->length == str.length) ? (this->str > str.str) : (this->length > str.length));
	}
	bool operator==(String str)
	{
		return ((this->length == str.length) && (this->str == str.str));
	}

};

1.冒泡排序

void buddle_sort(vector<String>s)
{
	int len = s.size();
	String temp(1);
	time_t time1 = clock();
	bool isswap = 0;
	for (int i = 0; i < len - 1; i++)
	{
		//每次排好序以后，最大的项肯定是在最右边，所以j只需要遍历到len-i-1就可以
		isswap = 0;
		for (int j = 0; j < len - 1 - i; j++)
		{
			//先按照长度排序
			if (s[j].length > s[j + 1].length)
			{
				isswap = 1;
				temp = s[j + 1];
				s[j + 1] = s[j];
				s[j] = temp;
			}
			//再按照字典序排序
			else if (s[j].length == s[j + 1].length)
			{
				if (s[j].str > s[j + 1].str)
				{
					isswap = 1;
					temp = s[j + 1];
					s[j + 1] = s[j];
					s[j] = temp;
				}
			}
		}
		if (!isswap)//全部都排好了没有交换
			break;
	}
	time_t time2 = clock();
	cout << "冒泡排序的时间为" << time2 - time1 << "ms" << endl;
}

2.选择排序

void select_sort(vector<String>s)
{
	int len = s.size();
	time_t time1 = clock();
	String temp;
	for (int i = 0; i <= len - 1; i++)
	{
		//暂定最小值是第i个元素
		String min = s[i];
		for (int j = i; j <= len - 1; j++)
		{
			if (min.length > s[j].length)
			{
				temp = min;
				min = s[j];
				s[j] = temp;
			}
			else if (min.length == s[j].length)
			{
				if (min.str > s[j].str)
				{
					temp = min;
					min = s[j];
					s[j] = temp;
				}
			}
		}
		s[i] = min;//从i以后选出一个最小的，放到i位置上
	}
	time_t time2 = clock();
	cout << "选择排序的时间为" << time2 - time1 << "ms" << endl;
}

3 插入排序

void insert_sort(vector<String>s)
{
	int len = s.size();
	time_t time1 = clock();
	int j;
	for (int i = 1; i <= len - 1; i++)
	{
		String temp = s[i];//空出第i个位置
		for (j = i - 1; (s[j].length == temp.length) ? (s[j].str > temp.str) : (s[j].length > temp.length) && j - 1 >= 0; j--)//往左边找，直到找到一个元素它小于或者等于该元素
		{
			s[j + 1] = s[j];
			if (j - 1 < 0)
				break;
		}
		//停下的位置的后一个是插入的位置，当前的j位置有一个元素
		s[j + 1] = temp;
	}
	time_t time2 = clock();
	cout << "插入排序的时间为" << time2 - time1 << "ms" << endl;//时间主要节省在不用交换元素上
}

4.希尔排序

这里重构了插入排序，以传入步长和起始位置

//插入排序重构,start代表分组的位置，space代表步长（间距）
void insert_sort(vector<String>& s, int start, int space)
{
	int len = s.size();

	for (int i = start + space; i <= len - 1; i += space)
	{
		String temp = s[i];
		int j = i - space;

		for (j = i - space; (s[j].length == temp.length) ? (s[j].str > temp.str) : (s[j].length > temp.length); j -= space)
		{
			s[j + space] = s[j];
			if (j - space < 0)
				break;
		}
		s[j + space] = temp;


	}
}
void Shell_sort(vector<String>s)
{
	int len = s.size();
	int space = len / 2;
	//分组，最开始的分组为数组长度的一半，每次
	time_t time1 = clock();
	for (; space >= 1; space /= 2)
	{
		//一共有space组，每一组的起始编号为i
		for (int i = 0; i <= space - 1; i++)
		{
			insert_sort(s, i, space);//将分好的组进行插入排序
		}
	}
	time_t time2 = clock();
	cout << "希尔排序的时间为" << time2 - time1 << "ms" << endl;
}

5.快速排序

因为有递归，所以选择了quick函数作为接口，方便计算时间（这里两个-2代表第一次初始化，但其实可以在quick函数里面初始化的，不想改了o(╥﹏╥)o）

void quick_sort(vector<String>& s, int start = -2, int end = -2, String key = 0)
{

	start = (start == -2) ? (0) : (start);
	end = (end == -2) ? (s.size() - 1) : (end);
	int start0 = start, end0 = end;
	if (start >= end)
	{
		return;
	}
	key = s[start];
	while (start < end)
	{
		while (start < end && (s[end].length == key.length) ? (s[end].str > key.str) : (s[end].length > key.length))//end逻辑上要比key大
			end--;
		s[start] = s[end];
		while (start < end && ((s[start].length == key.length) ? (s[start].str <= key.str) : (s[start].length <= key.length)))//start逻辑上要比key小
			start++;
		s[end] = s[start];
	}
	s[start] = key;
	quick_sort(s, start0, start - 1);
	quick_sort(s, start + 1, end0);
}
void quick(vector<String>s)
{
	time_t time1 = clock();
	quick_sort(s);
	time_t time2 = clock();
	cout << "快速排序的时间为" << time2 - time1 << "ms" << endl;
}

6.归并排序（真的好难）

首先定义了一个接口（因为要用到递归嘛），然后在merge_sort函数里面先分割数组，最后在归并，归并卸载了merge里面了，总体思路就这样吧

void merge(vector<String>& s, int s1, int len1, int s2, int len2)
{
	//分割数组
	int mid1 = s1 + len1 / 2;
	int mid2 = s2 + len2 / 2;
	int i1 = s1, i2 = s2, i = s1;
	int flag1 = 1, flag2 = 1;
	vector<String>temp;
	for (; i <= s1 + len1 + len2 - 1; i++)
	{

		//如果左边那个有序数组的第i1个小于等于右边有序数组的第i2个
		if ((((s[i1].length == s[i2].length) ? (s[i1].str <= s[i2].str) : (s[i1].length <= s[i2].length)) && flag1) || (flag2 == 0 && flag1 != 0))
		{
			//归并i1
			temp.push_back(s[i1]);
			if (i1 + 1 <= s1 + len1 - 1)	i1++;
			else { flag1 = 0; }
		}
		else if ((((s[i1].length == s[i2].length) ? (s[i1].str > s[i2].str) : (s[i1].length > s[i2].length)) && flag2) || (flag1 == 0 && flag2))
		{
			//归并i2
			temp.push_back(s[i2]);
			if (i2 + 1 <= s2 + len2 - 1)	i2++;
			else { flag2 = 0; }
		}
	}
	for (i = s1; i <= s1 + len1 + len2 - 1; i++)
		s[i] = temp[i - s1];

}
void merge_sort(vector<String>& s, int start, int end)
{
	int len = s.size();
	start = (start == -2) ? (0) : (start);
	end = (end == -2) ? (s.size() - 1) : (end);
	if (start < end)
	{
		int mid = (start + end) / 2;
		merge_sort(s, start, mid);
		merge_sort(s, mid + 1, end);

		merge(s, start, (mid - start + 1), mid + 1, (end - mid));

	}
	else
	{
		return;
	}
}
void merge_sort(vector<String>s)
{
	time_t time1 = clock();
	merge_sort(s, -2, -2);
	time_t time2 = clock();
	cout << "归并排序的时间为" << time2 - time1 << "ms" << endl;
}

7.堆排序

首先定义了一个最小堆Heap类，实现最小堆的构造和取最顶点

struct Heap
{
	//将vector数组建立成最小堆
	Heap(vector<String>& s)
	{
		int len = s.size();
		for (int i = 0; i <= len - 1; i++)
		{
			data[size + 1] = s[i];
			int index = ++size;
			for (; index > 1; index /= 2)
			{
				if ((data[index / 2].length == data[index].length) ? (data[index / 2].str > data[index].str) : (data[index / 2].length > data[index].length))
				{
					String temp = data[index / 2];
					data[index / 2] = data[index];
					data[index] = temp;
				}
			}
		}
	}
	String pop()
	{
		if (size)
		{
			String return_x = data[1];
			data[1] = data[size--];
			int index = 1;
			for (; index * 2 <= size;)
			{
				if (index * 2 == size)//只有左儿子
				{
					if (data[index] > data[index * 2])
					{
						swap(data[index], data[index * 2]);
						index = index * 2;
						break;
					}
					else
					{
						break;
					}
				}
				else if (data[index] > data[index * 2] || data[index] > data[index * 2 + 1])
				{
					if (data[index * 2] > data[index * 2 + 1])
					{
						swap(data[index], data[index * 2 + 1]);
						index = index * 2 + 1;
					}
					else
					{
						swap(data[index], data[index * 2]);
						index = index * 2;
					}
				}
				else
					break;
			}
			return return_x;
		}
		else
		{
			return 0;
		}
	}
	String data[MAXN + 1] = { 0 };
	int size = 0;

};

然后借助Heap类进行堆排序

void heap_sort(vector<String>& s)
{
	time_t time1 = clock();
	Heap* heap = new Heap(s);
	for (int i = 0; i <= heap->size - 1; i++)
	{
		s[i] = heap->pop();
	}
	time_t time2 = clock();
	cout << "堆排序的时间为" << time2 - time1 << "ms" << endl;
}

8.桶排序

设置字符串长length为一个桶，每+1为一个桶，用vector动态数组存储节省空间

void bucket_sort(vector<String>& s)
{
	if (s.size())
		quick_sort(s);
}
void divide_bucket(vector<String>s)
{
	time_t time1 = clock();
	int len = s.size();
	vector<vector<String> > bucket(s.size() + 1);
	for (int i = 0; i <= len - 1; i++)
	{
		//把s[i]放入指定的桶里面
		bucket[s[i].length].push_back(s[i]);
	}
	for (int i = 0; i <= len - 1; i++)
	{
		bucket_sort(bucket[i]);
	}
	int i = 1;
	s.clear();
	for (int i = 1; i <= len; i++)
	{
		for (int j = 0; j <= (int)bucket[i].size() - 1; j++)
		{
			s.push_back(bucket[i][j]);
		}
	}
	time_t time2 = clock();
	cout << "桶排序的时间为" << time2 - time1 << "ms" << endl;
}

附：最后是stl里面的sort（这里采用的是降序）

bool cmp(String s1, String s2)
{
	if ((s1.length == s2.length) ? (s1.str > s2.str) : (s1.length > s2.length))
	{
		return 1;//该交换了
	}
	else
	{
		return 0;//不交换
	}
}
void Sort(vector<String>s)
{
	time_t time1 = clock();
	sort(s.begin(), s.end(), cmp);
	time_t time2 = clock();
	cout << "STL: sort时间为:" << time2 - time1 <<"ms"<< endl;
}

最终结果如下：
在这里插入图片描述
可能略微有不准确的地方，因为其中运用的运算符和函数调用不完全相同

仅供参考~~

【C++】STL各容器的实现，时间复杂度，适用情况分析
Y先森0.0
10-08 5495
一.vector1.概述动态数组，在内存中具有连续的储存空间，在堆上分配内存，支持快速随机访问，在中间插入和删除慢，但在末尾插入和删除快2.特点1）拥有一段连续的内存空间，并且起始地址不变，因此能非常好的支持随机存取，但由于其内存空间是连续的，所以在中间插入和删除会造成内存块的拷贝，另外，当该数组的内存空间不够时，需要重新申请一块足够大的内存并进行内存拷贝，这些都大大的影响了vector...
利用sort函数排序（基于C++描述）
weixin_44442777的博客
06-07 775
二分查找算法是一种效率较高的查找方法，但其适用的数据本身是有要求的，即数据需要有序排列（单调增加或减少），因此要在使用二分查找之前，可以先对数据进行排序，而后再进行查找是一个比较可行的实现途径。本文则对利用sort()函数进行数据排序进行小结，后续会更新对于二分查找的相关总结。 一、关于sort（）函数 在C++语言中，sort函数可以对指定范围内的元素进行排序，排序规则默认以元素值的大小做升序排序，除此之外我们也可以自定义函数决定排序规则，以下将做进一步说明。 sort()函数包含在头文件
大学数据结构排序算法时间测试实验（适合初学者练手）
12-21
适合初学者学习C++数据结构练习的一个实验，排序算法时间测试，快速排序，归并排序及起泡排序法，请使用VS2013打开，如使用低版本请自己加载头文件和源文件。希望可以帮助到大家，谢谢（来自某大学软件工程的一名普通学生）！
线性度测试
weixin_30437847的博客
03-29 666
起先采用分段斜率与平均值比较的方法发现不太科学现在采用最小二乘法实现如下为 Pascal脚本实现代码 procedureZX2Multi(dx,dy:arrayofDouble;Count:Integer;vara,b:Double);//最小二乘法直线拟和y=ax+b;vari:Integer;x,y,xy,x2:Double;beginx:=...
归并排序+时间测试
Frank---7的博客
03-22 5718
package com.atguigu.sort; import java.text.SimpleDateFormat; import java.util.Arrays; import java.util.Date; /** * @创建人 wdl * @创建时间 2021/3/22 * @描述 */ public class MergeSort { public static void main(String[] args) { // int arr[]={8,4,5,7,
线性结构复杂度分析
diaolong123123的博客
03-22 195
1 顺序表大小为k 每个单位平均访问概率是1/k,访问复杂度是O(1) 增加、删除时间复杂度：1/k(1+2+...k)=O(k) 2 链表的插入次序：最好是把新加进来的元素的所有链处理完在处理和他相连的单元的链。 3 不要使用顺序表的情况： 1）经常插入、删除操作 2）线性表的最大长度也需要考虑 4 不要使用链表的情况 1）读操作比插入、删除操作频率大...
归并排序 自带时间复杂度测试
用可见的方式来记录和分享每一次收获
11-28 255
#include<iostream> #include<time.h> using namespace std; int tmp[250001]; void Sort(int List[], int l, int r); int main() { int a[250000]; int k, j; // 设置种子 srand((unsigned)time(NU...
C++排序详解：sort函数与自定义cmp
它提供了一种高效且灵活的方式来对序列进行排序，其时间复杂度通常为O(n*log(n))。 1. `sort`的基本用法： - 参数1：要排序的序列的起始迭代器。 - 参数2：序列的结束迭代器（不包括该位置的元素）。 - 参数3：...
比较排序算法实战：性能测试与实现
- **直接插入排序**：一个简单的线性时间复杂度O(n^2)排序算法，通过逐个比较元素并将其插入到已排序部分的正确位置。 - **希尔排序**：一种改进的插入排序，使用不同增量序列（如4，2，1），通过将待排序数组分割...
数据结构课程设计_排序算法比较【完整版】.doc
05-26
3. **性能评估**：对于每种排序算法，统计其排序给定序列所需的时间，并将这些时间统计结果以图表的形式展示出来。 #### 二、程序的主要功能 程序具有以下主要功能： 1. **用户输入**：允许用户输入希望生成的随机...
冒泡排序时间测试（自己编写）
01-14
冒泡排序时间测试，冒泡排序时间测试 冒泡排序时间测试
Java数据结构与算法———（45）测试归并排序花费的时间
GTboy100的博客
07-22 360
归并排序的效率比较高，对于8万个数据，处理的时间小于1秒；对于8百万个数据，处理的时间 一、代码 package sort; import java.text.SimpleDateFormat; import java.util.Date; public class MergeSort { public static void main(String[] args) { //测试80000个数据 int[] arr = new int[80000]; int[] temp = new i
Java编程：排序算法——归并排序
KaiSarH
09-29 358
Java编程：归并排序
排序算法测试-归并排序
Sunny的博客
05-02 333
1、测试代码 #include <iostream> using namespace std; int g_loop = 0; /* 循环计数 */ int g_move = 0; /* 数据移动次数 */ void output_info(int *buff,int len, int flag) { int i; if(0 == flag) ...
归并排序算法执行速度测试 [数据结构][Java]
m0_57001006的博客
08-21 131
【代码】归并排序算法执行速度测试 [数据结构][Java]
归并排序及测试算法速度
handsome_sai的博客
07-21 290
归并排序： 归并排序（MERGE-SORT）是利用归并的思想实现的排序方法，该算法采用经典的分治（divide-and-conquer）策略（分治法将问题分(divide)成一些小的问题然后递归求解，而(conquer)的阶段则将分的阶段得到的各答案"修补"在一起，即分而治之)。 实现步骤： 分：使用递归，实现分隔成单独的数据 治： 1）将数组中的元素按照从大到小的顺序排入到temp临时数组中，直到一侧完全排入 2）将剩下一侧依次排入temp中 3）将排好序的temp（临时数组）拷贝到arr
线性复杂度的素数筛选法
weixin_30894583的博客
07-22 101
// #include"cstdio" // #include"cstring" // using namespace std; // #define maxn 100000//求maxn范围内的素数 // long long su[maxn],cnt; // bool isprime[maxn]; // void prime() // { // cnt=1; // ...
C++学习笔记10 各种各样的排序算法复杂度
JackZhangNJU的专栏
09-06 526
各种排序的复杂度 C++中的qsort()采用的是快排算法，C++的sort()则是改进的快排算法。两者的时间复杂度都是nlogn，但是实际应用中，sort()一般要快些，建议使用sort()。 插入排序、冒泡排序、归并排序和基数排序是稳定的，其余的比如希尔排序、选择排序、堆排序、快速排序都是不稳定的。 插入排序 （Insertion Sort）： 插入排序的基本思想是，经过i-...
C++ 01-复杂度1 最大子列和问题
我是菜鸡
03-11 331
01-复杂度1 最大子列和问题 　　给定K个整数组成的序列{N1,N2,…,Nk}{N1,N2,…,Nk}\{N_1,N2,…,N_k\}，“连续子列”被定义为{Ni,Ni+1,…,Nj−1,Nj}{Ni,Ni+1,…,Nj−1,Nj}\{N_i,N_{i+1},…,N_{j-1},N_j\}，其中1≤i≤j≤K1≤i≤j≤K 1≤i≤j≤K。“最大子列和”则被定义为所有连续子列元素的和中最大者...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值