排序算法效率简单测试

最新推荐文章于 2022-06-04 13:34:43 发布
最新推荐文章于 2022-06-04 13:34:43 发布
阅读量472 收藏 1
点赞数 2
分类专栏： 小项目 文章标签： 排序算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34400232/article/details/60468256
版权

操作环境：win8.1+vs2015
说明：1、对直接插入排序、折半排序、希尔排序、冒泡排序、快速排序、选择排序、堆排序、归并排序的简单测试（生成5000个随机数测试执行时间）；
2、采用文件分离。

//file name:sort.h
#pragma once
#ifndef SORT_H
#define SORT_H

#define OK           1
#define ERROR        0
#define OVERFLOW    -1
#define MAXSIZE    5000  //待排序元素个数

typedef int Status;/*函数返回值类型*/
typedef int KeyType, InfoType;/*关键字类型和其他数据项的类型*/
typedef struct {
	KeyType key;
	InfoType otherinfo = 0;
}RedType;
typedef struct {
	RedType *r;
	int length;
}SqList;

typedef struct {
	double CostTime = 0.0;
	unsigned long MoveCount = 0;
	unsigned long CompareCount = 0;
}RunCondition, *pRunCondition;

Status InitSqList(SqList*);/*构造一个空顺序表*/
Status CreateSqList(SqList*);/*输入数据元素个数，随机产生整数样本*/
Status CopySqList(SqList, SqList*);
Status OutputSqList(SqList);/*输出排序后的数据*/
int LT(KeyType, KeyType);/*判断元素e1是否小于e2*/
void Swap(RedType*, RedType*);/*交换两元素*/
Status isEmpty(SqList);
Status InsertSort(SqList*, pRunCondition);/*直接插入排序*/
Status BInsertSort(SqList*, pRunCondition);/*折半排序*/
Status ShellInsert(SqList*, int,pRunCondition);/*一趟希尔排序*/
Status ShellSort(SqList*, int*, int,pRunCondition);/*希尔排序*/
Status BubbleSort(SqList*, pRunCondition);/*冒泡排序*/
int Partition(SqList*, int, int,pRunCondition);/*一趟快速排序*/
void QSort(SqList*, int, int,pRunCondition);
Status QuickSort(SqList*, pRunCondition);/*快速排序*/
Status SelectSort(SqList*, pRunCondition);/*选择排序*/
void HeapAdjust(SqList*, int, int,pRunCondition);
Status HeapSort(SqList*, pRunCondition);/*堆排序*/
Status Merge(SqList*, int, int, int,pRunCondition);
void MSort(SqList*, int,pRunCondition);
Status MergeSort(SqList*, pRunCondition);/*归并排序*/
#endif

//file name:sort.cpp
#include <stdio.h>
#include <math.h>
#include <time.h>
#include <stdlib.h>
#include "sort.h"

Status InitSqList(SqList *L)/*构造一个空顺序表*/
{
	L->r = (RedType*)malloc((MAXSIZE + 1) * sizeof(RedType));
	if (!L->r)//分配空间不成功
		exit(OVERFLOW);
	L->length = 0;
	return OK;
}//InitSqList

Status CreateSqList(SqList *L)/*输入数据元素个数，随机产生整数样本*/
{
	int i;

	srand((unsigned int)time(NULL));

	printf("\nPlease input the number of unsorted data:");
	scanf("%d", &L->length);

	for (i = 1; i <= L->length; ++i) {
		L->r[i].key = rand();
	}
	printf(">>>>>>>>>>>>>>>>>SUCCESS!\n");
	/*
	printf("\n\nThe unsorted data is:\n");
	for (i = 1; i <= L->length; ++i) {
		printf("%8d", L->r[i]);
	}
	*/
	return OK;
}//CreateSqList

Status CopySqList(SqList L_BAK, SqList *L)
{
	int i;
	
	if (!L_BAK.length) {
		printf("The SqList is empty!");
		return ERROR;
	}

	for (i = 1; i <= L_BAK.length; ++i) {
		L->r[i].key = L_BAK.r[i].key;
		L->r[i].otherinfo = L_BAK.r[i].otherinfo;
	}
	L->length = L_BAK.length;

	return OK;
}//CopySqList

Status OutputSqList(SqList L)/*输出排序后的数据*/
{
	int i;

	printf("\nThe length of SqList is:%d\n", L.length);

	printf("\n\nThe sorted data is:\n");
	for (i = 1; i <= L.length; ++i) {
		printf("%8d", L.r[i]);
	}
	printf("\n");

	return OK;
}//OutputSqList

int LT(KeyType e1, KeyType e2)/*判断元素e1是否小于e2*/
{
	return (e1 < e2) ? 1 : 0;
}//LT

void Swap(RedType *e1, RedType *e2)/*交换两元素*/
{
	RedType e;
	e = *e1;
	*e1 = *e2;
	*e2 = e;
}//Swap

Status isEmpty(SqList L)
{
	return (L.length) ? OK : ERROR;
}
/*直接插入排序*/
Status InsertSort(SqList *L, pRunCondition cnd)/*直接插入排序*/
{
	int i, j;

	if (isEmpty(*L) == ERROR) {
		printf("Empty SqList!\n");
		return ERROR;
	}

	for (i = 2; i <= L->length; ++i) {
		cnd->CompareCount++;//比较次数加1
		if (LT(L->r[i].key, L->r[i - 1].key)) {
			L->r[0] = L->r[i];
			L->r[i] = L->r[i - 1];
			cnd->MoveCount += 2;
			for (j = i - 2; LT(L->r[0].key, L->r[j].key); --j) {
				cnd->CompareCount++;
				cnd->MoveCount++;
				L->r[j + 1] = L->r[j];
			}//for
				L->r[j + 1] = L->r[0];
				cnd->MoveCount++;
		}//if
	}//for

	return OK;
}//InsertSort
/*折半插入排序*/
Status BInsertSort(SqList *L, pRunCondition cnd)/*折半排序*/
{
	int i, j, low, high, m;

	if (isEmpty(*L) == ERROR) {
		printf("Empty SqList!\n");
		return ERROR;
	}

	for (i = 2; i <= L->length; ++i) {
		L->r[0] = L->r[i];
		cnd->MoveCount++;
		low = 1;
		high = i - 1;
		while (low <= high) {
			m = (low + high) / 2;
			if (LT(L->r[0].key, L->r[m].key)) {
				high = m - 1;
			}
			else {
				low = m + 1;
			}
			cnd->CompareCount++;
		}//while
		
		for (j = i - 1; j >= high + 1; --j) {
			L->r[j + 1] = L->r[j];
			cnd->MoveCount++;
		}//for
		L->r[high + 1] = L->r[0];
		cnd->MoveCount++;
	}//for

	return OK;
}//BInsertSort
/*希尔排序*/
Status ShellInsert(SqList *L, int dk,pRunCondition cnd)/*一趟希尔排序*/
{
	int i, j;

	for (i = dk + 1; i <= L->length; ++i) {
		cnd->CompareCount++;
		if (LT(L->r[i].key, L->r[i - dk].key)) {
			L->r[0] = L->r[i];
			cnd->MoveCount++;
			for (j = i - dk; j > 0 && LT(L->r[0].key, L->r[j].key); j -= dk) {
				cnd->MoveCount++;
				cnd->CompareCount++;
				L->r[j + dk] = L->r[j];		
			}//for
			L->r[j + dk] = L->r[0];
			cnd->MoveCount++;
		}//if
	}//for

	return OK;
}//ShellInsert

Status ShellSort(SqList *L, int *dlta, int t,pRunCondition cnd)/*希尔排序*/
{
	int k;

	if (isEmpty(*L) == ERROR) {
		printf("Empty SqList!\n");
		return ERROR;
	}

	for (k = 0; k < t; ++k) {
		ShellInsert(L, dlta[k], cnd);
	}//for

	return OK;
}//ShellSort
/*冒泡排序*/
Status BubbleSort(SqList *L, pRunCondition cnd)/*冒泡排序*/
{
	int i, j;

	if (isEmpty(*L) == ERROR) {
		printf("Empty SqList!\n");
		return ERROR;
	}

	for (i = 1; i < L->length; ++i) {
		for (j = 1; j <= L->length - i; ++j) {
			cnd->CompareCount++;
			if (!LT(L->r[j].key, L->r[j + 1].key)) {
				Swap(&L->r[j], &L->r[j + 1]);
				cnd->MoveCount += 3;
			}
		}//for
	}//for

	return OK;
}//BubbleSort
/*快速排序*/
Status QuickSort(SqList *L, pRunCondition cnd)/*快速排序*/
{
	if (isEmpty(*L) == ERROR) {
		printf("Empty SqList!\n");
		return ERROR;
	}

	QSort(L, 1, L->length,cnd);
	
	return OK;
}//QuickSort

void QSort(SqList *L, int low, int high, pRunCondition cnd)
{
	int pivotloc;

	if (low < high) {
		pivotloc = Partition(L, low, high, cnd);
		QSort(L, low, pivotloc - 1, cnd);
		QSort(L, pivotloc + 1, high, cnd);
	}//if

}//QSort

int Partition(SqList *L, int low, int high, pRunCondition cnd)/*一趟快速排序*/
{
	KeyType pivotkey;

	L->r[0] = L->r[low];
	pivotkey = L->r[low].key;

	while (low < high) {
		while (low < high&&L->r[high].key >= pivotkey) {
			--high;
			cnd->CompareCount++;
		}//while;
		L->r[low] = L->r[high];//1次

		while (low < high&&L->r[low].key <= pivotkey) {
			++low;
			cnd->CompareCount++;
		}//while
		L->r[high] = L->r[low];//1次
		cnd->MoveCount += 2;
	}//while
	L->r[low] = L->r[0];
	cnd->MoveCount += 3;

	return low;
}//Partition
/*选择排序*/
Status SelectSort(SqList *L, pRunCondition cnd)/*选择排序*/
{
	int i, j, min;

	if (isEmpty(*L) == ERROR) {
		printf("Empty SqList!\n");
		return ERROR;
	}

	for (i = 1; i < L->length; ++i) {
		min = i;
		
		for (j = i + 1; j <= L->length; ++j) {
			cnd->CompareCount++;
			if (LT(L->r[j].key, L->r[min].key)) {
				min = j;
			}//if
		}//for
		if (min != i) {
			Swap(&L->r[i], &L->r[min]);
			cnd->MoveCount += 3;
		}//if
	}//for

	return OK;
}//SelectSort
/*归并排序*/
Status MergeSort(SqList *L, pRunCondition cnd)/*归并排序*/
{
	int len;

	if (isEmpty(*L) == ERROR) {
		printf("Empty SqList!\n");
		return ERROR;
	}

	for (len = 1; len < L->length; len *= 2) {
		MSort(L, len, cnd);
	}//for

	return OK;
}//MergeSort

void MSort(SqList *L, int len, pRunCondition cnd)
{
	int i;

	for (i = 1; i + 2 * len - 1 <= L->length; i += 2 * len) {
		Merge(L, i, i + len - 1, i + 2 * len - 1, cnd);
	}//for

	if (i + len - 1 < L->length) {
		Merge(L, i, i + len - 1, L->length,cnd);
	}//if
	
}//MSort

Status Merge(SqList *L, int low, int mid, int high, pRunCondition cnd)
{
	int i = low, j = mid + 1, k = 0;
	SqList L1;

	L1.r = (RedType*)malloc((high - low + 1) * sizeof(RedType));
	if (!L1.r) {
		exit(OVERFLOW);
	}//if

	while (i <= mid&&j <= high) {
		cnd->CompareCount++;
		cnd->MoveCount++;
		L1.r[k++] = LT(L->r[i].key, L->r[j].key) ? L->r[i++] : L->r[j++];
	}//while
	
	while (i <= mid) {
		cnd->MoveCount++;
		L1.r[k++] = L->r[i++];
	}//while

	while (j <= high) {
		cnd->MoveCount++;
		L1.r[k++] = L->r[j++];
	}//while

	for (k = 0, i = low; i <= high; k++, i++) {
		cnd->MoveCount++;
		L->r[i].key = L1.r[k].key;
	}//for

	return OK;
}//Merge
/*堆排序*/
Status HeapSort(SqList *L, pRunCondition cnd)/*堆排序*/
{
	int i;

	if (isEmpty(*L) == ERROR) {
		printf("Empty SqList!\n");
		return ERROR;
	}

	for (i = L->length / 2; i > 0; --i) {
		HeapAdjust(L, i, L->length, cnd);
	}//for
	for (i = L->length; i > 1; --i) {
		Swap(&L->r[1], &L->r[i]);
		cnd->MoveCount += 3;
		HeapAdjust(L, 1, i - 1, cnd);
	}//for

	return OK;
}//HeapSort

void HeapAdjust(SqList *L, int s, int m, pRunCondition cnd)
{
	int j;
	RedType rc = L->r[s];

	for (j = 2 * s; j <= m; j *= 2) {
		if (j < m&&LT(L->r[j].key, L->r[j + 1].key)) {
			++j;
		}//if
		if (!LT(rc.key, L->r[j].key)) {
			break;
		}//if
		L->r[s] = L->r[j];
		s = j;
		cnd->MoveCount++;
		cnd->CompareCount += 2;
	}//for
	L->r[s] = rc;
	cnd->MoveCount += 2;

}//HeapAdjust

//file name:sort_main.cpp
#include <stdio.h>
#include <math.h>
#include <time.h>
#include <stdlib.h>
#include <conio.h>
#include "sort.h"

#if 0
int main()
{
	SqList L, L_BAK;
	RunCondition rCnd[9];/*记录比较次数、移动次数，运行时间*/
	int t,select, flag = 1;
	int dlta[MAXSIZE];
	clock_t start, finish;

	InitSqList(&L);
	InitSqList(&L_BAK);

	CreateSqList(&L_BAK);
	/*产生希尔排序的增量序列dlta[0..t]*/
	t = 0;
	dlta[0] = (int)(L_BAK.length / 2);
	while (dlta[t] > 1) {
		dlta[t + 1] = dlta[t] / 2;
		++t;
	}

	while(flag){
		CopySqList(L_BAK, &L);
		
		printf("Please select:\n");
		printf("1.InsertSort\n");
		printf("2.BInsertSort\n");
		printf("3.ShellSort\n");
		printf("4.BubbleSort\n");
		printf("5.QuickSort\n");
		printf("6.SelectSort\n");
		printf("7.HeapSort\n");
		printf("8.MergeSort\n");
		printf("9.Exit\n");
	
	scanf("%d", &select);
	switch (select) {
	case 1:
		printf("\nNow is in InsertSort...");
		start = clock();
		InsertSort(&L, &rCnd[1]);
		finish = clock();
		rCnd[1].CostTime = (double)(finish - start);
		break;
	case 2:
		printf("\nNow is in BInsertSort...");
		start = clock();
		BInsertSort(&L, &rCnd[2]);
		finish = clock();
		rCnd[2].CostTime = (double)(finish - start);
		break;
	case 3:
		printf("\nNow is in ShellSort...");
		start = clock();
		ShellSort(&L, dlta, t + 1, &rCnd[3]);
		finish = clock();
		rCnd[3].CostTime = (double)(finish - start);
		break;
	case 4:
		printf("\nNow is in BubbleSort...");
		start = clock();
		BubbleSort(&L, &rCnd[4]);
		finish = clock();
		rCnd[4].CostTime = (double)(finish - start);
		break;
	case 5:
		printf("\nNow is in QuickSort...");
		start = clock();
		QuickSort(&L, &rCnd[5]);
		finish = clock();
		rCnd[5].CostTime = (double)(finish - start);
		break;
	case 6:
		printf("\nNow is in SelectSort...");
		start = clock();
		SelectSort(&L, &rCnd[6]);
		finish = clock();
		rCnd[6].CostTime = (double)(finish - start);
		break;
	case 7:
		printf("\nNow is in HeapSort...");
		start = clock();
		HeapSort(&L, &rCnd[7]);
		finish = clock();
		rCnd[7].CostTime = (double)(finish - start);
		break;
	case 8:
		printf("\nNow is in MergeSort...");
		start = clock();
		MergeSort(&L, &rCnd[8]);
		finish = clock();
		rCnd[8].CostTime = (double)(finish - start);
		break;
	default:
		flag = 0;
		printf("Press any key to exit!\n");
		getch();

	}//switch

	printf("\n");
	OutputSqList(L, rCnd[select]);
	}//while

	return 0;
}
#endif
Status Test();
int main()
{
	Test();

	getch();
	return 0;
}
Status Test()
{
	SqList L, L_BAK;
	RunCondition rCnd[9];/*记录比较次数、移动次数，运行时间*/
	int t, select = 0, flag = 1;
	int dlta[MAXSIZE];
	clock_t start, finish;

	InitSqList(&L);
	InitSqList(&L_BAK);

	CreateSqList(&L_BAK);
	/*产生希尔排序的增量序列dlta[0..t]*/
	t = 0;
	dlta[0] = (int)(L_BAK.length / 2);
	while (dlta[t] > 1) {
		dlta[t + 1] = dlta[t] / 2;
		++t;
	}

	while (flag) {
		if (select >= 0 && select < 8) {
			CopySqList(L_BAK, &L);
		}

		select++;

		switch (select) {
		case 1:
			printf("\nNow is in InsertSort...");
			start = clock();
			InsertSort(&L, &rCnd[1]);
			finish = clock();
			rCnd[1].CostTime = (double)(finish - start);
			break;
		case 2:
			printf("\nNow is in BInsertSort...");
			start = clock();
			BInsertSort(&L, &rCnd[2]);
			finish = clock();
			rCnd[2].CostTime = (double)(finish - start);
			break;
		case 3:
			printf("\nNow is in ShellSort...");
			start = clock();
			ShellSort(&L, dlta, t + 1, &rCnd[3]);
			finish = clock();
			rCnd[3].CostTime = (double)(finish - start);
			break;
		case 4:
			printf("\nNow is in BubbleSort...");
			start = clock();
			BubbleSort(&L, &rCnd[4]);
			finish = clock();
			rCnd[4].CostTime = (double)(finish - start);
			break;
		case 5:
			printf("\nNow is in QuickSort...");
			start = clock();
			QuickSort(&L, &rCnd[5]);
			finish = clock();
			rCnd[5].CostTime = (double)(finish - start);
			break;
		case 6:
			printf("\nNow is in SelectSort...");
			start = clock();
			SelectSort(&L, &rCnd[6]);
			finish = clock();
			rCnd[6].CostTime = (double)(finish - start);
			break;
		case 7:
			printf("\nNow is in HeapSort...");
			start = clock();
			HeapSort(&L, &rCnd[7]);
			finish = clock();
			rCnd[7].CostTime = (double)(finish - start);
			break;
		case 8:
			printf("\nNow is in MergeSort...");
			start = clock();
			MergeSort(&L, &rCnd[8]);
			finish = clock();
			rCnd[8].CostTime = (double)(finish - start);
			break;
		default:
			flag = 0;
			printf("Press any key to show the result!\n");
			getch();

		}//switch
		printf("\nThe sort spend:%.2lf s\nMove count:%ld\tCompare count:%ld\n", rCnd[select].CostTime/CLOCKS_PER_SEC, rCnd[select].MoveCount, rCnd[select].CompareCount);

		printf("-------------------------------------------\n\n");
	}//while

	OutputSqList(L);

	return OK;
}
Futuroscopeaaa
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【Java】七大基础排序算法-效率测试
qq_35491579的博客
04-12 872
【Java】基础排序算法-效率测试 文章目录前言一、测试对象（各排序算法及其优化程序）二、[测试程序](https://blog.csdn.net/qq_35491579/article/details/123623510?spm=1001.2014.3001.5501)总结 前言 前面几篇文章总结了七大排序的原理、写法以及优化方法，这篇文章我将利用一个简单的测试程序来对这些排序算法的效率进行一个对比测试。其中排序算法和测试程序都总结在往期文章里。 一、测试对象（各排序算法及其优化程序） 冒泡排序（bu
排序算法 之 效率测试
aa8635830的博客
05-12 151
前面我们写了常见的几种排序算法，并分析了各种算法的实现思想，及时间复杂度等情况，但由于只是分析，木有实际的数据做对比测试，所以对各个算法的效率也没有一个明确的概念，下面我们就通过具体的测试来看看同算法之间的效率差距。 声明11个长度为100的元素取值范围为0到1000的序列 int length = 100; int[] testArray1 = new int[lengt...
排序算法效率比较
qq_56023706的博客
12-12 258
排序算法效率比较。编程实现以下几种不同的排序算法（以升序为例）：冒泡排序、选择排序、 希尔排序、快速排序，比较不同的排序过程的运行时间。 具体要求： 为了消除数据之间差异导致排序效果的影响，使用相同的数组进行排序，方法为：首先创建一个数组，数组长度至少为100000，数组元素取值范围在[0, 100000]之间的随机正整数，并将这个数组复制4份，分别用不同的排序算法进行排序。 记录不同排序算法的运行时间。 对完全逆序的情况进行测试，将待排序数组赋值为逆序，即与最终排序要求完全相反。 im
java 快速排序_JAVA面试题：5分钟了解快速排序
weixin_39958248的博客
12-02 266
前言快速排序是面试中经常会问到的一种排序算法，对比其他一些排序算法，快速排序的平均时间相对较少。快速排序思想介绍快速排序使用了分治的思想，通过一轮的排序，可以将序列分割成独立的两个部分，其中一部分的值均比基准值小，另一部分的值均比基准值大。而后针对两部分序列再分别按照同样的算法进行排序，直到序列整体有序。以如下序列arr为例进行升序排序，说明快速排序的基本算法第一个位置的值23作为基准值base，...
排序算法的效率
08-25 340
目录 冒泡排序 快速排序 选择排序 堆排序 插入排序 希尔排序 合并排序 稳定排序的概念 对于大小为n的排序数据量： 冒泡排序 https://blog.csdn.net/Doutd_y/article/details/81911362 计算复杂度：平均速度为，最坏情况下的速度为 快速排序 与冒泡排序类似，也是基于交换排序的思想。https://blog.csdn.ne...
Java常用排序算法及性能测试集合
09-05
本文将深入探讨几种常见的Java排序算法，包括其工作原理、性能特点以及如何进行性能测试。 首先，我们来看冒泡排序（Bubble Sort）。冒泡排序是最简单直观的排序算法之一，通过不断交换相邻的逆序元素来逐渐推进...
冒泡排序是一种简单的排序算法.pdf
最新发布
07-04
冒泡排序（Bubble Sort）是一种简单直观的比较排序算法。它的基本思想是从第一个元素开始，依次比较相邻的两个元素，若前一个元素大于后一个元素，则将两者交换位置。这样，较大的元素就会像气泡一样逐渐上浮至数列...
1.认识复杂度和简单排序算法1
08-03
本节我们将深入探讨时间复杂度、简单排序算法以及评估算法效率的方法。 时间复杂度是衡量算法运行时间与输入数据量之间的关系，通常用大O记法表示。常数操作，如赋值`int a = arr[i]`或基本算术运算`+-*/`、位运算...
实验十 排序算法1
08-03
本实验主要关注三种经典的排序算法：冒泡排序、选择排序和快速排序，通过对这些算法的理解、实现和分析，可以提升对算法效率和性能的理解。 1. 冒泡排序（Bubble Sort） 冒泡排序是一种简单的排序算法，通过比较...
Python实现的选择排序算法示例
09-21
选择排序（Selection Sort）是一种简单直观的比较排序算法。它的基本思想是：在未排序序列中找到最小（或最大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（或最大）元素，然后放到已...
排序算法及效率
06-10
在排序中使用到的几种算法及效率对比
对一些常见的排序算法进行演算测试，对比效率。（JAVA 实现）
卖画的作家
05-02 382
大三下了，正在找实习，把一些常用的排序算法重新复习一遍，同时简单的比较了一下各个算法的效率，总的来说，快排效率最高，冒泡效率最低。-----具体的排序算法包括：直接插入排序、折半插入排序、Shell排序（插入排序） 冒泡、快速排序（交换排序）欢迎大家一起讨论，如有错误务必指出~~~先验证排序算法的正确性：接着比较效率（注释掉了打印数组的功能）：得出结论：当待排数的数量较大时（示例中采用102400...
常见排序算法的C++实现&&亿级排序效率测试
牛~
07-15 613
选择排序 插入排序 冒泡排序 希尔排序 归并排序 快速排序及优化 对于100000000/一亿个int型数组排序 简单测试排序时间，目前测试结果 Shell Sort : 40.211 s Quick Sort : 39.22 s 希尔排序与快速排序两者不相上下 对于500000000/一亿个int型数组排序 简单测试排序时间，目前测试结果 Shell Sort : 275.252 s ...
排序算法时间效率测试
wjwever1的博客
11-02 749
对快速排序，归并排序，希尔排序的时间效率进行了一个测试。 归并排序果然厉害，我的希尔排序写的估计有点问题，太慢。#include <iostream> #include <algorithm> #include <ctime> #include <fstream> using namespace std; //quick sort int partition(int *data, int firs
浅谈排序算法的效率（一）—（Java随笔）
远处
10-01 2418
排序算法有很多种，每一种都有其优缺点，可以适应不同的场合。排序算法的好坏，主要是看排序效率，排序效率的一个重要指标就是速度，速度是影响排序算法的最主要因素。 一般来说，判断一个算法的优劣，可以从以下两个方面进行： 算法的复杂度：以O表示，往往从最差，平均，最好三种情况来评价。 系统资源的占用：主要是内存和其他资源的占用，一个好的算法应该占用少的内存资源。 常用排序算法——计算复杂度比较： ...
排序算法运行效率问题
weixin_43827285的博客
04-25 369
十大经典排序算法（动图演示） 各个算法的时间、空间复杂度如下图所示： 在此博主用python对其中六大排序算法进行编程，源码和运行结果如下（如有问题，欢迎在评论区批评指出）： # -*- coding: utf-8 -*- """ Created on Sun Apr 19 23:18:40 2020 @author: 44886 """ import copy import time imp...
浅谈排序算法的效率（二）—（Java随笔）
远处
10-02 831
首先：咱也借用一下网上的那张XXX的图，咯！在下面： 接下来，就是咱的验证时间了（验证什么？当然是各种算法的时间复杂度咯），没什么好说的了，直接上码吧。 代码实现： import java.util.Arrays; public class SortSummary { /** * 各排序算法效率比较 */ // 1、冒泡排序 int[] bubbleSort(int...
常用排序算法的效率
yjh201301的博客
01-25 239
int  Partition(int* data, int low, int high) {     int  key = data[low];     while  (low         while (low             if (key                 --high;             }             else {    
【排序】九大排序性能测试-时间复杂度【附性能测试代码】
后端开发为主+人工智能
06-04 591
【九大排序】性能测试 【附性能测试代码】
比较各类排序算法的时间效率
1. **直接插入排序**：这是一种简单的排序算法，它通过将每个元素插入到已排序部分的正确位置来逐步构建有序序列。对于小规模或大部分已排序的数据，插入排序表现出良好的性能。 2. **希尔排序**：希尔排序是一种...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值