排序算法分析（c++）

最新推荐文章于 2021-05-23 18:04:10 发布
最新推荐文章于 2021-05-23 18:04:10 发布
阅读量312 收藏 1
点赞数
文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/baidu_38634843/article/details/84677367
版权

题目分析

选择排序、冒泡排序、归并排序、快速排序、插入排序等排序算法，都是常见的内部排序算法。

  1. 选择排序也是一种简单直观的排序算法。
  2. 冒泡排序也是一种简单直观的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。
  3. 归并排序是建立在归并操作上的一种有效的排序算法。该算法是采用分治法的一个非常典型的应用。
  4. 快速排序是由东尼·霍尔所发展的一种排序算法。在平均状况下，排序m个项目要Ο(n log n)次比较。在最坏状况下则需要Ο(n2)次比较，但这种状况并不常见。事实上，快速排序通常明显比其他Ο(n log n) 算法更快。快速排序使用分治法策略来把一个串行分为两个子串行。
  5. 插入排序是一种最简单直观的排序算法，它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。

算法分析

1. 选择排序

   (1) 首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置

   (2) 再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。

   (3) 重复第二步，直到所有元素均排序完毕。

      2. 冒泡排序

        (1) 比较相邻的元素。如果第一个比第二个大，就交换他们两个。

        (2) 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。

        (3) 针对所有的元素重复以上的步骤，除了最后一个。

        (4) 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

      3. 归并排序

      (1) 申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列。

      (2) 设定两个指针，最初位置分别为两个已经排序序列的起始位置。

      (3) 比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位。

      (4) 重复步骤3直到某一指针达到序列尾。

      (5) 将另一序列剩下的所有元素直接复制到合并序列尾

      4. 快速排序

       (1) 从数列中挑出一个元素，称为 “基准”。

       (2) 重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区操作。

       (3) 递归地把小于基准值元素的子数列和大于基准值元素的子数列排序。

递归的最底部情形，是数列的大小是0或1，也就是永远都已经被排序好了。虽然一直递归下去，但是这个算法总会退出，因为在每次的迭代（iteration）中，它至少会把一个元素摆到它最后的位置去。

      5. 插入排序

     将第一待排序序列第一个元素看作一个有序序列，把第二个元素到最后一个元素当成是未排序序列。

      从头到尾依次扫描未排序序列，将扫描到的每个元素插入有序序列的适当位置。（如果待插入的元素与有序序列中的某个元素相等，则将待插入元素插入到相等元素的后面。）

算法实现

数据规模实现代码：

void sorted::number(int a[], int m)//将m个数传入数组a[]
{
int i;//循环变量
for (i = 0; i < m; i++)//进行m次循环
{
a[i] = rand() % 100 + 1;//随机生成1-100之间的数m个
}
cout << "\n数据规模为" << m << "时" << endl;
}

随机产生0-100之内的m个数，m为数据规模，m=10,100，1000,10000,100000。

时间计算实现代码：

使用switch结构，选择需要计算的排序时间：

/*时间计算函数，通过此函数可以计算不同排序算法的时间*/
void sorted::time(int m)//m表示数组中的数据规模
{
double avg=0;//保存平均时间的变量
double sum=0;//记录数组中20组时间的总和变量
double total[20] = {0};//定义每一次排序时间的数组
clock_t start, finish;//时间开始与结束变量
number(a, m);//调用number函数向数组a中产生m个数
cout << "20组样本(ms):" << endl;
switch (c){//用switch结构
case 1:
cout << "选择排序" << endl;
for (i = 0; i < 20; i++)//进行20组排序测试
{
start = clock();/*开始计时*/
Select_sort(a, m);//选择排序,,传入数组a和数据规模m
finish = clock();//结束计时
total[i] = (double)(finish - start) * 1000 / CLOCKS_PER_SEC;//此时间为ms表示
cout << " " << total[i];//输出时间为结合时间-开始时间
}
break;
case 2:
cout << "冒泡排序" << endl;
for (i = 0; i < 20;i++)//进行20组排序测试
{
start = clock();/*开始计时*/
Bubble_sort(a, m);//冒泡排序，传入数组a和数据规模m
finish = clock();//结束计时
total[i] = (double)(finish - start) * 1000 / CLOCKS_PER_SEC;//此时间为ms表示
cout << " " << total[i];//输出时间为结合时间-开始时间
}
break;	
case 3:
cout << "合并排序" << endl;
for (i = 0; i < 20; i++)//进行20组排序测试
{
start = clock();/*开始计时*/
merge_sort(a,0,m);//合并排序,传入数组a，开始值，结束值m
finish = clock();//结束计时
total[i] = (double)(finish - start) * 1000 / CLOCKS_PER_SEC;//此时间为ms表示
cout << " " << total[i];//输出时间为结合时间-开始时间
}
break;
case 4:
cout << "快速排序" << endl;
for (i = 0; i < 20; i++)//进行20组排序测试
{
start = clock();/*开始计时*/
quick_sort(a, 0, m);//快速排序,,传入数组a,开始值，结束值m
finish = clock();//结束计时
total[i] = (double)(finish - start) * 1000 / CLOCKS_PER_SEC;//此时间用ms表示
cout << " " << total[i];//输出每一次运行的时间
}
break;
case 5:
cout << "插入排序" << endl;
for (i = 0; i < 20; i++)//进行20组排序测试
{
start = clock();/*开始计时*/
insert_sort(a, m);//插入排序,传入数组a和数据规模m
finish = clock();//结束计时
total[i] = (double)(finish - start) * 1000 / CLOCKS_PER_SEC;//此时间为ms表示
cout << " " << total[i];//输出时间为结合时间-开始时间
}
break;
}
for (int i = 0; i < 20; i++)//将20组测试的每一次时间加起来
{
sum += total[i];//相加的值赋给sum
}
avg = sum / 20;//平均时间
cout << "\n平均花费时间(ms):" <<avg<<"    ";//计算20组排序的平均时间
}

选择排序算法实现：

void sorted::Select_sort(int a[], int len)//a[]为传入的数组，len为数组长度
{
int min, temp;//min为小值，temp用于交换大值与小值
for (int i = 0; i < len - 1; i++)//从第一个数开始遍历，长度为0到（len-1）
{
min = i;//将i的值赋给min
for (int j = i + 1; j<len; j++)//在剩下的数中进行遍历
{
if (a[min]>a[j])//如果遍历的数组中前一个数大于后一个数
min = j;//将数组下标交换
}
/*将大值与小值交换，保证小值在前面*/
temp = a[i];
a[i] = a[min];
a[min] = temp;
}
}

冒泡排序算法实现：

void sorted::Bubble_sort(int a[], int len)
{
int i;//局部循环变量
int temp;//局部交换中间变量
for (i = 0; i < len - 1; i++)//循环len-1次
{
for (int j = 0; j < len - 1 - i; j++)//循环len-1-i次
{
if (a[j]>a[j + 1])//如果前一个数大于后一个数
{
/*交换前数与后数，使得小的数永远在大的数前面*/
temp = a[j];
a[j] = a[j + 1];
a[j + 1] = temp;
}
}
}
}

合并排序算法实现：

void sorted::merge(int a[], int left, int middle, int right)
{
//left表示从左向右遍历，right表示从右向左遍历
//将left的值赋给t，i，i用来遍历数组，middle+1的值赋给j
int t = left, i = left, j = middle + 1;
//如果i<middle且数组没有遍历完，则继续循环，否则退出循环
while (i <= middle&&j <= right){
if (a[i] <= a[j]) //判断左边遍历值是否小于从右边遍历的值
temp[t++] = a[i++];//小于等于，将左边遍历的值赋给temp数组
else 
temp[t++] = a[j++];//大于，将从右边遍历的值赋给temp数组
}
while (i <= middle) //如果i小于中间值
temp[t++] = a[i++];//左边值赋给temp数组
while (j <= right) //如果j小于中间值
temp[t++] = a[j++];//右边元素赋给temp数组
for (int i = left; i <= right; ++i)//left!=right则一直遍历
a[i] = temp[i];//将temp的值赋给a
}
/*合并排序主要函数*/
void sorted::merge_sort(int a[], int left, int right)
{
if (left == right)//结束递归条件
return;
int middle = (left + right) / 2;//中间值middle
merge_sort(a, left, middle);   //分解
merge_sort(a, middle + 1, right);  //分解
merge(a, left, middle, right);  //合并
}

快速排序算法实现：

/*快速排序，low为从头开始，high为从尾开始*/
int sorted::Partition(int a[], int low, int high)
{
int x = a[high];//将输入数组的最后一个数作为主元，用它来对数组进行划分
int i = low - 1;//i是最后一个小于主元的数的下标
for (int j = low; j < high; j++)//遍历下标由low到high-1的数
{
if (a[j] < x)//如果数小于主元的话就将i向前挪动一个位置，并且交换j和i所分别指向的数
{
int temp;
i++;
temp = a[i];//交换大值与小值，使大值始终在小值后面
a[i] = a[j];
a[j] = temp;
}
}
//经历上面的循环之后下标为从low到i（包括i）的数就均为小于x的数了，现在将主元和i+1位置上面的数进行交换
a[high] = a[i + 1];
a[i + 1] = x;
return i + 1;
}
/*快速排序主函数，low为*/
void sorted::quick_sort(int a[], int low, int high)
{
if (low < high)//如果没有遍历完数组
{
int q = Partition(a, low, high);
quick_sort(a, low, q - 1);//递归调用
quick_sort(a, q + 1, high);//递归调用
}
}

插入排序算法实现：

void sorted::insert_sort(int a[],int len)
{
for (int i = 1; i<len; i++){//遍历1-len，即从1-len-1次循环
int tmp = a[i];//将数组值赋给tmp
int j = i - 1;//循环变量j=i-1
while (j >= 0 && tmp<a[j]){//循环条件
a[j + 1] = a[j];//将小值与大值进行交换
j--;//从后向前遍历
}
a[j + 1] = tmp;//即a[j+1]=a[i]
}
}

类设计代码：

class sorted{
public:
int m;//定义数据个数的变量
int i;//循环变量
int c;//用户输入值
public :
void  Select_sort(int a[], int len);//选择排序函数，len=m
void  Bubble_sort(int b[], int len);//冒泡排序
void  number(int a[], int m);//产生m个随机数的函数
void  time(int m); //此函数中包含相同的时间计算方法
void  merge_sort(int a[], int left, int right);//合并排序主要递归函数
void  merge(int a[], int left, int middle, int right);//合并排序的递归参数函数
void  quick_sort(int a[], int low, int high);//快速排序
int   Partition(int a[], int low, int high);//快速排序递归参数
void  insert_sort(int a[],int len);//插入排序
};

 主函数：

/*主函数*/
int main()
{
	sorted s;//定义sorted类对象
	cout << "请选择排序方法" << endl;
	cout << "1. 选择排序 2. 冒泡排序 3.归并排序 4.快速排序 5.插入排序" << endl;
	cin >> s.c;//从键盘输入选择
	switch (s.c)
	{
	case 1:   //选择排序函数
		s.time(10);//产生10个数据，调用此函数间接调用排序算法以及时间计算
		system("pause");//暂停
		s.time(100);//产生100个数据
		system("pause");//暂停
		s.time(1000);//产生1000个数据
		system("pause");//暂停
		s.time(10000);//产生10000个数据
		system("pause");//暂停
		s.time(100000);//产生100000个数据
		break;
	case 2:
		s.time(10);//产生10个数据，调用此函数间接调用排序算法以及时间计算
		system("pause");//暂停
		s.time(100);//产生100个数据
		system("pause");//暂停
		s.time(1000);//产生1000个数据
		system("pause");//暂停
		s.time(10000);//产生10000个数据
		system("pause");//暂停
		s.time(100000);//产生100000个数据
		break;
	case 3:
		s.time(10);//产生10个数据，调用此函数间接调用排序算法以及时间计算
		system("pause");//暂停
		s.time(100);//产生100个数据
		system("pause");//暂停
		s.time(1000);//产生1000个数据
		system("pause");//暂停
		s.time(10000);//产生10000个数据
		system("pause");//暂停
		s.time(100000);//产生100000个数据
		break;
	case 4:
		s.time(10);//产生10个数据，调用此函数间接调用排序算法以及时间计算
		system("pause");//暂停
		s.time(100);//产生100个数据
		system("pause");//暂停
		s.time(1000);//产生1000个数据
		system("pause");//暂停
		s.time(10000);//产生10000个数据
		system("pause");//暂停
		s.time(100000);//产生100000个数据
		break;
	case 5:
		s.time(10);//产生10个数据，调用此函数间接调用排序算法以及时间计算
		system("pause");//暂停
		s.time(100);//产生100个数据
		system("pause");//暂停
		s.time(1000);//产生1000个数据
		system("pause");//暂停
		s.time(10000);//产生10000个数据
		system("pause");//暂停
		s.time(100000);//产生100000个数据
		break;
	}
	return 0;

其他排序算法调用与之相同。

运行结果

 选择排序运行结果：

图1 选择排序在不同数据规模下排序所消耗的时间

冒泡排序运行结果：

图2 冒泡排序在不同数据规模下排序所消耗的时间

合并排序运行结果：

图3 合并排序在不同数据规模下排序所消耗的时间

快速排序的运行结果

图4 快速排序在不同数据规模下排序所消耗的时间

插入排序运行结果

算法复杂度分析及经验归纳

算法复杂度：

排序算法

平均时间复杂度

最好情况

最坏情况

空间复杂度

稳定性

选择排序

不稳定

冒泡排序

稳定

合并排序

稳定

快速排序

不稳定

插入排序

稳定

经验归纳：

在进行快速排序算法实现过程中，出现了堆栈溢出问题，检查发现是递归结束条件没有写好，重新改正递归出口后程序得以正确运行。

在编写合并排序过程中，出现了数组无法存储10000个数的问题，检查发现数组被定义为局部变量，改为全局变量后可以存储超过100000个以上的数。

通过这些问题的出现以及处理，我对于数组在不同定义下存储数据规模的大小有了更直观的认识，通过算法，我也更加认识到当要处理的数据足够大时，好的算法可以使程序运行更快，效率更高。也充分认识到好的算法在开发中的重要性。

源代码：

#include<iostream>
#include<stdlib.h>
#include<math.h>
#include<time.h>
using namespace std;
int temp[100001];//定义全局数组temp
int a[100001];//定义全局数组a
/*定义类排序*/
class sorted{
public:
	int m;//定义数据个数的变量
	int i;//循环变量
	int c;//用户输入值
public :
	void  Select_sort(int a[], int len);//选择排序函数，len=m
	void  Bubble_sort(int b[], int len);//冒泡排序
	void  number(int a[], int m);//产生m个随机数的函数
	void  time(int m); //此函数中包含相同的时间计算方法
	void  merge_sort(int a[], int left, int right);//合并排序主要递归函数
	void  merge(int a[], int left, int middle, int right);//合并排序的递归参数函数
	void  quick_sort(int a[], int low, int high);//快速排序
	int   Partition(int a[], int low, int high);//快速排序递归参数
	void  insert_sort(int a[],int len);//插入排序
};
/*时间计算函数，通过此函数可以计算不同排序算法的时间*/
void sorted::time(int m)//m表示数组中的数据数量
{
	double avg=0;//保存平均时间的变量
	double sum=0;//记录数组中20组时间的总和变量
	double total[20] = {0};//定义每一次排序时间的数组
	clock_t start, finish;//时间开始与结束变量
	number(a, m);//调用number函数向数组a中产生m个数
	cout << "20组样本(ms):" << endl;
	switch (c){//用switch结构
			case 1:
				cout << "选择排序" << endl;
				for (i = 0; i < 20; i++)//进行20组排序测试
				{
					start = clock();/*开始计时*/
					Select_sort(a, m);//选择排序,,传入数组a和数据规模m
					finish = clock();//结束计时
					total[i] = (double)(finish - start) * 1000 / CLOCKS_PER_SEC;//此时间为ms表示
					cout << " " << total[i];//输出时间为结合时间-开始时间
				}
				break;
			case 2:
				cout << "冒泡排序" << endl;
				for (i = 0; i < 20;i++)//进行20组排序测试
				{
					start = clock();/*开始计时*/
					Bubble_sort(a, m);//冒泡排序，传入数组a和数据规模m
					finish = clock();//结束计时
					total[i] = (double)(finish - start) * 1000 / CLOCKS_PER_SEC;//此时间为ms表示
					cout << " " << total[i];//输出时间为结合时间-开始时间
			}
				break;	
			case 3:
				cout << "合并排序" << endl;
				for (i = 0; i < 20; i++)//进行20组排序测试
				{
					start = clock();/*开始计时*/
					merge_sort(a,0,m);//合并排序,传入数组a，开始值，结束值m
					finish = clock();//结束计时
					total[i] = (double)(finish - start) * 1000 / CLOCKS_PER_SEC;//此时间为ms表示
					cout << " " << total[i];//输出时间为结合时间-开始时间
				}
				break;
			case 4:
				cout << "快速排序" << endl;
				for (i = 0; i < 20; i++)//进行20组排序测试
				{
					start = clock();/*开始计时*/
					quick_sort(a, 0, m);//快速排序,,传入数组a,开始值，结束值m
					finish = clock();//结束计时
					total[i] = (double)(finish - start) * 1000 / CLOCKS_PER_SEC;//此时间用ms表示
					cout << " " << total[i];//输出每一次运行的时间
				}
				break;
			case 5:
				cout << "插入排序" << endl;
				for (i = 0; i < 20; i++)//进行20组排序测试
				{
					start = clock();/*开始计时*/
					insert_sort(a, m);//插入排序,传入数组a和数据规模m
					finish = clock();//结束计时
					total[i] = (double)(finish - start) * 1000 / CLOCKS_PER_SEC;//此时间为ms表示
					cout << " " << total[i];//输出时间为结合时间-开始时间
				}
				break;
	}
	for (int i = 0; i < 20; i++)//将20组测试的每一次时间加起来
	{
		sum += total[i];//相加的值赋给sum
	}
	 avg = sum / 20;//平均时间
	 cout << "\n平均花费时间(ms):" <<avg<<"    ";//计算20组排序的平均时间
		}
/*此函数为在数组中产生m个数据，m=10,100,1000,10000,100000*/
void sorted::number(int a[], int m)//将m个数传入数组a[]
{
	int i;//循环变量
	for (i = 0; i < m; i++)//进行m次循环
	{
		a[i] = rand() % 100 + 1;//随机生成1-100之间的数m个
	}
	cout << "\n数据规模为" << m << "时" << endl;
}
/*选择排序*/
void sorted::Select_sort(int a[], int len)//a[]为传入的数组，len为数组长度
{
	int min, temp;//min为小值，temp用于交换大值与小值
	for (int i = 0; i < len - 1; i++)//从第一个数开始遍历，长度为0到（len-1）
	{
		min = i;//将i的值赋给min
		for (int j = i + 1; j<len; j++)//在剩下的数中进行遍历
		{
			if (a[min]>a[j])//如果遍历的数组中前一个数大于后一个数
				min = j;//将数组下标交换
		}
		/*将大值与小值交换，保证小值在前面*/
		temp = a[i];
		a[i] = a[min];
		a[min] = temp;
	}
}
/*冒泡排序*/
void  sorted::Bubble_sort(int a[], int len)
{
	int i;//局部循环变量
	int temp;//局部交换中间变量
	for (i = 0; i < len - 1; i++)//循环len-1次
	{
		for (int j = 0; j < len - 1 - i; j++)//循环len-1-i次
		{
			if (a[j]>a[j + 1])//如果前一个数大于后一个数
			{
				/*交换前数与后数，使得小的数永远在大的数前面*/
				temp = a[j];
				a[j] = a[j + 1];
				a[j + 1] = temp;
			}
		}
	}
}
/*合并排序递归函数*/
//left 为遍历开始值一般为0，middle为数组的中间下标，right为遍历结束下标
void sorted::merge(int a[], int left, int middle, int right)
{
	//left表示从左向右遍历，right表示从右向左遍历
	//将left的值赋给t，i，i用来遍历数组，middle+1的值赋给j
	int t = left, i = left, j = middle + 1;
	//如果i<middle且数组没有遍历完，则继续循环，否则退出循环
	while (i <= middle&&j <= right){
		if (a[i] <= a[j]) //判断左边遍历值是否小于从右边遍历的值
			temp[t++] = a[i++];//小于等于，将左边遍历的值赋给temp数组
		else 
			temp[t++] = a[j++];//大于，将从右边遍历的值赋给temp数组
	}
	while (i <= middle) //如果i小于中间值
		temp[t++] = a[i++];//左边值赋给temp数组
	while (j <= right) //如果j小于中间值
		temp[t++] = a[j++];//右边元素赋给temp数组
	for (int i = left; i <= right; ++i)//left!=right则一直遍历
		a[i] = temp[i];//将temp的值赋给a
}
/*合并排序主要函数*/
void sorted::merge_sort(int a[], int left, int right)
{
	if (left == right)//结束递归条件
		return;
	int middle = (left + right) / 2;//中间值middle
	merge_sort(a, left, middle);   //分解
	merge_sort(a, middle + 1, right);  //分解
	merge(a, left, middle, right);  //合并
}
 /*快速排序，low为从头开始，high为从尾开始*/
 int sorted::Partition(int a[], int low, int high)
 {
	 int x = a[high];//将输入数组的最后一个数作为主元，用它来对数组进行划分
	 int i = low - 1;//i是最后一个小于主元的数的下标
	 for (int j = low; j < high; j++)//遍历下标由low到high-1的数
	 {
		 if (a[j] < x)//如果数小于主元的话就将i向前挪动一个位置，并且交换j和i所分别指向的数
		 {
			 int temp;
			 i++;
			 temp = a[i];//交换大值与小值，使大值始终在小值后面
			 a[i] = a[j];
			 a[j] = temp;
		 }
	 }
	 //经历上面的循环之后下标为从low到i（包括i）的数就均为小于x的数了，现在将主元和i+1位置上面的数进行交换
	 a[high] = a[i + 1];
	 a[i + 1] = x;
	 return i + 1;
 }
 /*快速排序主函数，low为*/
void sorted::quick_sort(int a[], int low, int high)
 {
	if (low < high)//如果没有遍历完数组
	{
		int q = Partition(a, low, high);
		quick_sort(a, low, q - 1);//递归调用
		quick_sort(a, q + 1, high);//递归调用
	}
 }
 /*插入排序,a为数组，len 为数组中数据规模*/
 void sorted::insert_sort(int a[],int len)
 {
	 for (int i = 1; i<len; i++){//遍历1-len，即从1-len-1次循环
		 int tmp = a[i];//将数组值赋给tmp
		 int j = i - 1;//循环变量j=i-1
		 while (j >= 0 && tmp<a[j]){//循环条件
			 a[j + 1] = a[j];//将小值与大值进行交换
			 j--;//从后向前遍历
		 }
		 a[j + 1] = tmp;//即a[j+1]=a[i]
	 }
 }
/*主函数*/
int main()
{
	sorted s;//定义sorted类对象
	cout << "请选择排序方法" << endl;
	cout << "1. 选择排序 2. 冒泡排序 3.归并排序 4.快速排序 5.插入排序" << endl;
	cin >> s.c;//从键盘输入选择
	switch (s.c)
	{
	case 1:   //选择排序函数
		s.time(10);//产生10个数据，调用此函数间接调用排序算法以及时间计算
		system("pause");//暂停
		s.time(100);//产生100个数据
		system("pause");//暂停
		s.time(1000);//产生1000个数据
		system("pause");//暂停
		s.time(10000);//产生10000个数据
		system("pause");//暂停
		s.time(100000);//产生100000个数据
		break;
	case 2:
		s.time(10);//产生10个数据，调用此函数间接调用排序算法以及时间计算
		system("pause");//暂停
		s.time(100);//产生100个数据
		system("pause");//暂停
		s.time(1000);//产生1000个数据
		system("pause");//暂停
		s.time(10000);//产生10000个数据
		system("pause");//暂停
		s.time(100000);//产生100000个数据
		break;
	case 3:
		s.time(10);//产生10个数据，调用此函数间接调用排序算法以及时间计算
		system("pause");//暂停
		s.time(100);//产生100个数据
		system("pause");//暂停
		s.time(1000);//产生1000个数据
		system("pause");//暂停
		s.time(10000);//产生10000个数据
		system("pause");//暂停
		s.time(100000);//产生100000个数据
		break;
	case 4:
		s.time(10);//产生10个数据，调用此函数间接调用排序算法以及时间计算
		system("pause");//暂停
		s.time(100);//产生100个数据
		system("pause");//暂停
		s.time(1000);//产生1000个数据
		system("pause");//暂停
		s.time(10000);//产生10000个数据
		system("pause");//暂停
		s.time(100000);//产生100000个数据
		break;
	case 5:
		s.time(10);//产生10个数据，调用此函数间接调用排序算法以及时间计算
		system("pause");//暂停
		s.time(100);//产生100个数据
		system("pause");//暂停
		s.time(1000);//产生1000个数据
		system("pause");//暂停
		s.time(10000);//产生10000个数据
		system("pause");//暂停
		s.time(100000);//产生100000个数据
		break;
	}
	return 0;
}

 

--水木
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
排序算法分析（C++）
WLY_959的博客
09-28 416
几种排序算法。
C++ 算法 排序 分析
qq_34262886的博客
08-04 342
九大排序算法（注：递增）1. 冒泡排序a. 原理b.代码c.解释2. 选择排序a. 原理b.代码c.解释3. 插入排序a. 原理b.代码c.解释4. 快速排序a. 原理b.代码c.解释5. 堆排序a. 原理b.代码c.解释6.计数排序a. 原理b.代码c.解释7.基数排序a. 原理b.代码c.解释8.希尔排序a. 原理b.代码c.解释9.归并排序a. 原理b.代码c.解释 所谓排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。排序算法，就是如何使得记录按照要求排列的方法。排
测试快速排序对一亿个数据进行排序花费的时间
ytc958374686的博客
12-24 842
import java.text.SimpleDateFormat; import java.util.Date; public class QuickSort { public static void main(String[] args) { int[] array = new int[100000000]; for (int i = 0; i &l...
C/C++经典算法细解
无奇不有 不置可否的博客
05-23 1872
一、会议安排算法 贪心算法–会议安排问题 1. 问题描述 在有限的时间内有很多会议要召开，每个会议有开始和结束时间要求任何两个会议不能同时进行， 会议安排问题要求就是在所给的会议集合中选出最大的相容活动子集，即尽可能在有限的时间内召开更多的会议。 2. 算法设计 每次从剩下未安排会议中选出最早结束且与已安排会议不冲突的会议【选最早结束时间】 #include "stdio.h" #define n 10 struct TypeElem { //定义开始结束时间 int Begin,
不同排序算法(插入+冒泡+堆+合并+快速)算法设计
06-19
分别实现插入排序、冒泡排序、堆排序、合并排序、快速排序,以不同规模(100,1000,2000,5000,10000,100000个数据)的随机数作为测试数据集,分别设置比较操作计数器,验证各个算法随着测试数据集增加比较次数的变化趋势
不同排序算法的实现和性能比较
05-04
分别实现插入排序、冒泡排序、堆排序、合并排序、快速排序,以不同规模(100,1000,2000,5000,10000,100000个数据)的随机数作为测试数据集,分别设置比较操作计数器,验证各个算法随着测试数据集增加比较次数的变化趋势。 2、对每一个测试数据集,比较这些排序方法之间的性能,并用软件工具绘制出性能对比的曲线图。 注意： (1) 结果展示之前应交代测试环境、数据规模和形式、测试方法、性能指标及结果采集方式。
排序算法之--快速排序(及优化测试亿级100_000_000用时)
diaobiaorou8393的博客
08-08 176
该方法的基本思想是： 1．先从数列中取出一个数作为基准数。 2．分区过程，将比这个数大的数全放到它的右边，小于或等于它的数全放到它的左边。 3．再对左右区间重复第二步，直到各区间只有一个数。 挖坑填数+分治法： 对挖坑填数进行总结 1．i =L; j = R; 将基准数挖出形成第一个坑a[i]。 2．j--由后向前找比它小的数，找到后挖出此数填前一个坑a[i]中。 3．i...
几个排序算法的C++实现
最新发布
02-03
在编程领域，排序算法是计算机科学中的核心概念，特别是在数据结构和算法分析中。C++是一种强大且广泛应用的编程语言，常用于实现各种高效的算法。本项目提供了几个经典的排序算法的C++实现，有助于理解这些算法的...
C++线性时间的排序算法分析
09-04
以下是对三种非比较排序算法——计数排序、基数排序和桶排序的详细分析。 **一、比较排序算法的时间下界** 比较排序算法是通过比较元素来决定其相对顺序。著名的定理指出，对于包含n个元素的输入序列，任何基于比较...
C++实现常用排序算法
07-15
在编程领域，排序算法是计算机科学中的基础但至关重要的部分，尤其在C++这样的系统级编程语言中。本文将深入探讨C++实现的几种常见排序算法：冒泡排序、选择排序、插入排序、归并排序、快速排序以及堆排序。 1. **...
C++排序算法之插入排序
08-25
本文主要介绍了C++排序算法之插入排序的基本思想、算法实现和时间复杂度分析。插入排序是一种简单的排序算法，通过将未排序的数据元素按大小顺序插入到已排好序数据序列中实现排序。 基本思想 插入排序的基本思想...
实验八 排序（插入排序、归并排序、快速排序）
悲伤无声地涌出来
01-01 2366
发现一个不大不小的bug，每次第一种方法排完序后，第二、第三种排序时都是对已排好序的数组进行排序了。。 所以应该借助一下temp数组，第一、二种方法排完序后将A数组还原成一开始无序的状态，比较时间代码及运行结果未修改。 以下代码仅供参考 2019-1-3更新 ------------------------------------------------------------------...
排序方法分析与代码实现
weixin_43525722的博客
09-28 148
排序也称排序算法(Sort Algorithm)，排序是将一组数据，依指定的顺序进行排列的过程。鉴于经常面试中需要考察本方面的内容，也为了后期及时复习相关知识，故在此将算法相关知识系列进行总结记录，以便学习使用，希望对看到这些文章的你有所帮助。 本系列将从以下两个方面对排序相关知识进行总结整理： 排序的相关概念理解 排序各类算法的分析和代码实现 所以会分为两篇文章进行整理。这里是第一篇，也就是第一部分排序的相关概念理解，废话不多说，咱们直接进入正题。 排序的分类 内部排序: 指将需要处理的所有数据都加载到
常见排序算法流程分析及其实现代码
智慧包的博客
09-02 658
一、直接插入排序 1、执行流程 每趟将一个待排序的关键字按照其大小插入到已经排好序的部分的适当位置上，直到所有待排序关键字都被插入到有序序列中为止 原始序列：49 38 65 97 76 13 27 49 （序列中有两个49，其中一个加粗加以区分并可以验证该排序算法稳定性） 1）首先看49，直接放入有序序列中   49   38 65 97 76 13 27 49 2）插入38，38<49，所以38插入49之前   38 49   65 97 76 13 27 49 3）插入65，65>49，所
排序算法分析及实现C++
喵小苡的博客
03-29 190
参考资料： 经典排序算法过程、经典排序算法性质、《王道数据结构》、严蔚敏《数据结构》 概念 稳定：如果a原本在b前面，而a=b，排序之后a仍然在b的前面。 不稳定：如果a原本在b的前面，而a=b，排序之后 a 可能会出现在 b 的后面。 时间复杂度：对排序数据的总的操作次数。反映当n变化时，操作次数呈现什么规律。 空间复杂度：是指算法在计算机内执行时所需存储空间的度量，它也是数据规模n的函数...
数据结构 各种排序排列100000个数所需的是时间-洋葱先生-杨少通
前端小白的逆袭
09-20 1633
注：本程序由Visual Studio 2015编写，与VC++6.0稍有区别，复制到VC++6.0注释掉“#include “stdafx.h””即可运行，复制到VS可直接运行。 #include “stdafx.h” #include #include <stdlib.h> #include <time.h> #include<process.h> #include <Windows.h> using namespace std; #define OK
数据结构与算法分析c++版本学习总结
11-07 2563
主要记录了数据结构的学习心得和总结，方便以后参阅 第一章 引论 该部分主要介绍了一些基本概念和数学基础 1、递归 当一个函数用自身来定义时就称为递归（recursive）。 递归的基本法则： 1）基准情形。必须存在某些基准情形作为递归的终止形式。 2）不断推进。总能够朝着一个基准情形推进。 3）设计法则。假设所有递归调用都能运行。 4）合成效益法则。在求解一个问题的同
快速排序不同输入规模时间复杂度分析
后来者居上
06-17 629
import java.util.Random;public class QuickSort { public static void quickSort(int[] a, int low, int high) { int i, j; int temp; i = low; j = high; temp = a[low]; // 取第一个元
《数据结构与算法分析C++》课后答案解析
"《数据结构与算法分析C++答案》是Clifford A. Shaffer编写的《数据结构与算法分析》第二版的配套解答手册，涵盖了从基础的数据结构和算法到高级的树形结构、算法分析技术以及计算的局限性等多个主题。书中提供了...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值