[C++] 七种常见排序算法的实现及运行效率对比（算法课实验）

已于 2022-03-02 13:59:52 修改
阅读量3.8k 收藏 37
点赞数 7
分类专栏： 数据结构与算法设计 TJOJ小课堂 文章标签： c++ 排序算法 算法 数据结构
于 2022-03-02 13:59:04 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_62405272/article/details/123228288
版权

简介

本文实现以下七种排序算法：

  • 插入排序

  • 选择排序

  • 冒泡排序

  • 希尔排序

  • 堆排序

  • 快速排序

  • 归并排序

使用 C++ 完成，并测试运行时间。

算法说明

以下针对每种算法，从网络摘取简介，并附实现代码。

所有实现以对 int 数组排序，目标为从小到大为例。感兴趣的读者可以自行编写更通用的写法。

插入排序

插入排序是一种最简单直观的排序算法，它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。

void insertSort(int* first, int* last) {
	for (int* p = first + 1; p < last; p++) {
		int* curr = p;
		for (int* q = p - 1; q >= first; q--) {
			if (*q > *curr) {
				swap(*q, *curr);
				curr--;
			}
			else {
				break;
			}
		}
	}
}

选择排序

第一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，然后再从剩余的未排序元素中寻找到最小（大）元素，然后放到已排序的序列的末尾。以此类推，直到全部待排序的数据元素的个数为零。

void selectSort(int* first, int* last) {
	for (int* p = first; p < last; p++) {
		int* tar = p;
		for (int* q = p + 1; q < last; q++) {
			if (*q < *tar) {
				tar = q;
			}
		}

		swap(*tar, *p);
	}
}

冒泡排序

重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢"浮"到数列的顶端。

void bubbleSort(int* first, int* last) {
	for (int* i = first; i < last; i++) {
		for (int* j = i; j < last; j++) {
			if (*i > *j) {
				swap(*i, *j);
			}
		}
	}
}

希尔排序

希尔排序，也称递减增量排序算法，是插入排序的一种更高效的改进版本。但希尔排序是非稳定排序算法。

void shellSort(int* first, int* last) {
	int step = last - first;
	int*& arr = first;

	while (step > 1) {
		step /= 2;
		
		for (int i = 0; i < step; i++) {
			for (int j = i + step; j < last - first; j += step) {
				for (int k = j - step; k >= 0; k -= step) {
					if (arr [k] > arr [k + step]) {
						swap(arr [k], arr [k + step]);
					}
					else {
						break;
					}
				}
			}
		}
	}
}

堆排序

堆排序（Heapsort）是指利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。堆排序可以说是一种利用堆的概念来排序的选择排序。

void heapSort(int* first, int* last) {
	int*& arr = first;
	int len = last - first;
	
	auto lc = [](int x) { return 2 * x + 1; };
	auto rc = [](int x) { return 2 * x + 2; };

	auto adjust = [&](int tar, int borderIdx) {
		int curIdx = tar;

		while (true) {
			int curMaxIdx = curIdx;
			if (lc(curIdx) < borderIdx && arr[lc(curIdx)] > arr[curMaxIdx]) {
				curMaxIdx = lc(curIdx);
			}
			if (rc(curIdx) < borderIdx && arr[rc(curIdx)] > arr[curMaxIdx]) {
				curMaxIdx = rc(curIdx);
			}

			if (curMaxIdx != curIdx) {
				swap(arr[curIdx], arr[curMaxIdx]);
				curIdx = curMaxIdx;
			}
			else {
				break;
			}
		}
	};

	for (int i = len / 2 - 1; i >= 0; i--) {
		adjust(i, len);
	}

	for (int i = len - 1; i > 0; i--) {
		swap(arr[0], arr[i]);
		adjust(0, i);
	}
}

快速排序

在平均状况下，排序 n 个项目要 Ο(nlogn) 次比较。在最坏状况下则需要 Ο(n2) 次比较，但这种状况并不常见。事实上，快速排序通常明显比其他 Ο(nlogn) 算法更快，因为它的内部循环（inner loop）可以在大部分的架构上很有效率地被实现出来。

注意：不可使用递归形式完成。否则当数据量较大的时候，会导致栈溢出。

void quickSort(int* first, int* last) {
	vector<pair<int*, int*>> q;

	q.push_back(make_pair(first, last));

	while (!q.empty()) {
		pair<int*, int*> currPair = q.back();
		q.pop_back();

		int* currFirst = currPair.first;
		int* currLast = currPair.second;

		if (currFirst + 1 >= last) {
			return;
		}

		int* lp = currFirst;
		int* rp = currLast - 1;

		while (lp < rp) {
			
			while (lp < rp && *lp <= *rp) { // 右边界收缩。
				rp--;
			}

			swap(*lp, *rp);
			
			while (lp < rp && *lp <= *rp) { // 左边界收缩。
				lp++;
			}

			swap(*lp, *rp);
		}

		if (lp - 1 > currFirst) {
			q.push_back(make_pair(currFirst, lp));
		}

		if (rp + 1 < currLast - 1) {
			q.push_back(make_pair(rp + 1, currLast));
		}
	}
}

归并排序

归并排序（Merge Sort）是建立在归并操作上的一种有效，稳定的排序算法，该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。

void mergeSort(int* first, int* last) {
	// 迭代法。

	int* arrA = first;
	int size = last - first;
	int* arrB = new int[size];

	int* currSource = arrA;
	int* currTarget = arrB;

	for (int seqLen = 1; seqLen < size; seqLen *= 2) {

		for (int i = 0; i < size; i += seqLen * 2) {
			if (i + seqLen >= size) {
				memcpy(currTarget + i, currSource + i, (size - i) * sizeof(int));
				break;
			}

			int crA = i;
			int crB = i + seqLen;
			int tailA = i + seqLen;
			int tailB = min(i + 2 * seqLen, size);


			for (int j = i; j < i + 2 * seqLen && j < size; j++) {
				if (crA == tailA) {
					currTarget[j] = currSource[crB];
					crB += 1;
				}
				else if (crB == tailB) {
					currTarget[j] = currSource[crA];
					crA += 1;
				}
				else if (currSource[crA] < currSource[crB]) {
					currTarget[j] = currSource[crA];
					crA += 1;
				}
				else {
					currTarget[j] = currSource[crB];
					crB += 1;
				}
			}
		}

		swap(currSource, currTarget);
	}

	if (currSource == arrB) {
		memcpy(arrA, arrB, size * sizeof(int));
	}

	delete[] arrB;
}

包装

为方便测试，对程序加入命令行选择能力，并加入计时和结果检查。

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <algorithm>
#include <chrono>
#include <string>
#include <cmath>
#include <vector>
#include <conio.h>
using namespace std;

#undef swap
#undef sort

int getTimeMillisec() {
	return chrono::duration_cast<chrono::milliseconds>
		(chrono::system_clock::now().time_since_epoch()).count();
}

void swap(int& a, int& b) {
    int t = a; 
    a = b;
    b = t;
}

void bubbleSort(int* first, int* last) {...}
void quickSort(int* first, int* last) {...}
void selectSort(int* first, int* last) {...}
void insertSort(int* first, int* last) {...}
void mergeSort(int* first, int* last) {...}
void shellSort(int* first, int* last) {...}
void heapSort(int* first, int* last) {...}

enum class Algo {
	QUICK, BUBBLE, SELECT, MERGE, INSERT, SHELL, HEAP
};

int sort(int* first, int* last, Algo algo = Algo::QUICK) {
	auto beg = getTimeMillisec();

	if (algo == Algo::QUICK) {
		quickSort(first, last);
	} else if (algo == Algo::BUBBLE) {
		bubbleSort(first, last);
	} else if (algo == Algo::SELECT) {
		selectSort(first, last);
	} else if (algo == Algo::MERGE) {
		mergeSort(first, last);
	} else if (algo == Algo::INSERT) {
		insertSort(first, last);
	} else if (algo == Algo::SHELL) {
		shellSort(first, last);
	} else if (algo == Algo::HEAP) {
		heapSort(first, last);
	}

	auto now = getTimeMillisec();
	return now - beg;
}

int main(int argc, const char* argv[]) {
	ios::sync_with_stdio(false);
	srand(time(0));

	string algoStr = "quick";
	if (argc >= 2) {
		algoStr = argv[1];
	} else {
		cout << "Usage: [Algorithm] [optional: qsop]" << endl;
		cout << endl;
		cout << "Available algorithms are:" << endl;
		cout << "    quick, bubble, merge, heap, insert, shell, select." << endl;
		cout << endl;
		cout << "if quicksort-optimization is required, add \"qsop\" to the arguments." << endl;
		cout << endl;
		cout << "Example:" << endl;
		cout << argv[0] << " quick op : optimized quick sort." << endl;
		return 0;
	}

	bool isOpRequired = false;
	if (argc >= 3 && strcmp(argv[2], "qsop") == 0) {
		isOpRequired = true;
	}

	Algo algo = Algo::QUICK;
	if (algoStr == "quick") {
		algo = Algo::QUICK;
		cout << "algo set: quick sort." << endl;
	} else if (algoStr == "bubble") {
		algo = Algo::BUBBLE;
		cout << "algo set: bubble sort." << endl;
	} else if (algoStr == "merge") {
		algo = Algo::MERGE;
		cout << "algo set: merge sort." << endl;
	} else if (algoStr == "heap") {
		algo = Algo::HEAP;
		cout << "algo set: heap sort." << endl;
	} else if (algoStr == "insert") {
		algo = Algo::INSERT;
		cout << "algo set: insert sort." << endl;
	} else if (algoStr == "shell") {
		algo = Algo::SHELL;
		cout << "algo set: shell sort." << endl;
	} else if (algoStr == "select") {
		algo = Algo::SELECT;
		cout << "algo set: select sort." << endl;
	}

	int n;
	cin >> n;
	int* arr = new int[n];

	for (int i = 0; i < n; i++) {
		cin >> arr[i];
	}

	if (isOpRequired) {
		// 随机打乱
		for (int i = 0; i < n / 33; i++) {
			swap(arr[rand() % n], arr[rand() % n]);
		}
	}

	time_t timeUsage = sort(arr, arr + n, algo);

	for (int i = 0; i < n; i++) {
		if (i < 6 || n - i < 6) {
			cout << arr[i] << ' ';
		}
		else if (i == 10) {
			cout << "... ";
		}

		if (i > 0 && arr[i - 1] > arr[i]) {
			cout << endl;
			cout << "Seq Error: at arr[" << i << "]." << endl;
			cout << "exit? [y/n]: ";
			while (true) {
				char c = _getch();
				if (c == 'Y' || c == 'y') {
					cout << c << endl;
					i = n; // break the outer loop.
					break;
				} else if (c == 'N' || c == 'n') {
					cout << c << endl;
					break;
				}
			}
		}
	}
	cout << endl;
	cout << "time usage: " << timeUsage << " ms." << endl;
	delete[] arr;
	return 0;
}

测试文件生成程序

使用简短的 Kotlin 程序生成测试文件。通过命令行方式控制生成数据的规模等。

随机

import java.io.File
fun main(args: Array<String>) {
	if (args.size < 2) {
		println("Usage: [data size] [outfile dir]")
		println("Example: name 1000 ./out1000.txt")
		return
	}
	
	val s = args[0].toInt()
	val file = File(args[1])
	file.printWriter().use { out ->
		out.println(s)
		for (i in 0 until s) {
			out.print("${(0..s).random()} ")
		}
		out.println()
	}
}

有序

import java.io.File
enum class Order {
	ASC, DES
}
fun main(args: Array<String>) {
	if (args.size < 2) {
		println("Usage: [order: \"ass\" or \"rev\"] [outfile] [optional: data size]")
		return
	}
	
	val size = if (args.size >= 3) args[2].toInt() else 10000
	val order = if (args[0].lowercase() == "des") Order.DES else Order.ASC
	val file = File(args[1])
	
	file.printWriter().use { out ->
		out.println(size)
		var curr = if (order == Order.ASC) 0 else size
		for (i in 0 until size) {
			out.print("$curr ")
			if ((0..100).random() < 70) {
				curr += if (order == Order.ASC) 1 else -1
			}
		}
		out.println()
	}
}

测试结果

测试分别运行于笔记本电脑和 arm64 服务器。采用自动测试并输出结果的模式，各完成64种组合的排序并计时。

最终，得到以下测试结果。

其中，快速排序（优化）在快速排序的基础上，随机打乱 3% 的数据，从而避免极端情况使快速排序算法复杂度退化。

计时单位：毫秒 (ms)

笔记本

插入选择冒泡希尔堆快速快速（优化）归并
1000000000
10000000000
1K01200000
10K307510510101
100K281176131095097566
1M279138 (279s)783016 (13min)1226214 (20min)150103646979
10K 正序07911001110
10K 逆序568135011100

服务器

插入选择冒泡希尔堆快速快速（优化）归并
1000000000
10000000000
1K12500001
10K15018743433231
100K1516318739430514646252520
1M1579726 (26min)1904198 (32min)4480618 (75min)738630290286243
10K 正序01861861316270
10K 逆序2982545261317541

排序算法比较

下表为各种排序算法的性能指标。

排序算法时间复杂度（平均）时间复杂度（最坏）空间复杂度稳定备注
插入O(n2)O(n2)O(1)是
希尔O(n1.3)O(n2)O(1)否
选择O(n2)O(n2)O(1)否
堆O(nlogn)O(nlogn)O(1)否
冒泡O(n2)O(n2)O(1)是
快速O(nlogn)O(n2)O(nlogn)否数列有序时，快速排序严重退化
快速（优化）O(nlogn)O(nlogn)O(1)否排序前随机打乱数列
归并O(nlogn)O(nlogn)O(n)是需要一个辅助数组

从前方实验中可以看出，O(n2) 的复杂度在数据量较大的时候耗时严重。

当数列有序时，快速排序和冒泡的效率几乎一致。将数列进行小幅度随机打乱可以规避此问题。

优缺点分析

算法优点缺点
插入无额外内存开销。稳定。效率低下。
希尔比选择效率高。无额外内存开销。效率依旧低下。
选择无额外内存开销。效率低下。
堆效率高。无额外内存开销。
冒泡稳定。数据移动次数过多。效率低下。
快速时间复杂度低。计算过程空间复杂度较高。不稳定。数列有序时，效率退化。
快速（优化）不论数列是否有序，都有较高效率。计算过程空间复杂度较高。不稳定。
归并效率高。额外空间开销较小。存在额外空间开销。

数据生成环境

软件

Kotlinc: 1.6.10 (JRE 17.0.1+12)

Java: 17 (64 bit)

测试环境：笔记本电脑

硬件

CPU型号：i7-11370H

内存频率：LPDDR4X 4266MHz

软件

操作系统：Windows 11 Pro 21H1 (22000.527) x86_64

C++编译器：MSVC v143 （以 release x64 模式编译）

测试环境：服务器

硬件

CPU: 鲲鹏920 arm64 2.6GHz

软件

操作系统：Ubuntu 20.04 focal (aarch64 Linux 5.4.0-100-generic)

C++编译器：gcc 9.3.0

枫铃树
关注
  • 7
    点赞
  • 踩
  • 37
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
计算C++程序执行时间 精确到毫秒级
flyyufenfei的博客
03-31 3388
参考别人的自己总结的。本人水平有限，有错误麻烦指出。两种方法：（请忽略冒泡排序）第一种：#include &lt;iostream&gt; #include &lt;vector&gt; #include &lt;time.h&gt; #include &lt;sys/timeb.h&gt; #include &lt;Windows.h&gt; using namespace std; void ...
c++排序方法效率比较
06-06
在C++环境下对几种排序算法的效率进行比较!不过写得相当粗糙！望多多指教！
C++ 六大排序算法实现和比较
406156440的博客
08-20 2627
文章目录一. 快速排序1.1 介绍1.2 函数片段1.3 快排应用二. 归并排序2.1 介绍2.2 函数片段三. 插入排序3.1 介绍3.2 函数片段四. 冒泡排序4.1 介绍4.2 函数片段五. 选择排序5.1 介绍5.2 函数片段六. 桶排序 常用的排序算法 本文介绍多种排序算法, 利用图示进行解析 最后部分是整个可执行带主函数的代码\color{#FF3030}{带主函数的代码}带主函数的代码 一. 快速排序 1.1 介绍 快速排序是一种查找一个值的绝对位置, 根据此位置将序列分成左右两个位置
C++ 排序算法实现 及 性能比较
lanwanjunxixihaha的专栏
02-05 1599
include include include include include define HeapLeft(i) (2*i+1)define HeapRight(i) (2*i+2)define HeapParent(i) ((i-1)/2)void InitMinHeap(HeapElemType arr[],int size){ int cur=0,curVal; for
排序算法的应用及效率的比较C++
weixin_51626421的博客
06-27 634
​ 数据结构课程设计之排序算法的应用及效率的比较。 ​
冒泡排序
热门推荐
suiyueweinitingliu的博客
07-25 3万+
冒泡排序 冒泡排序（Bubble Sort，台湾译为：泡沫排序或气泡排序）是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工>作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越大的元素会经由交换慢慢“浮”到数列的顶端，故名。如下图所示：   代码实现 <?php
c++实现12个排序算法以及时间比较
01-27
在这个项目中，"c++实现12个排序算法以及时间比较"，我们将会探讨这些算法的实现细节、效率和适用场景。 1. **冒泡排序(Bubble Sort)** 冒泡排序是最基础的排序算法之一，通过不断交换相邻的不正确顺序的元素来...
几个排序算法的C++实现
02-03
本项目提供了几个经典的排序算法的C++实现，有助于理解这些算法的工作原理以及如何在实际编程中应用它们。 1. **冒泡排序（Bubble Sort）**： 冒泡排序是一种简单的排序算法，通过不断交换相邻的逆序元素来逐渐把...
C++冒泡、快速、选择、归并等排序算法实现示例.rar
最新发布
05-07
综上所述，本压缩包中的示例代码可以帮助学习者深入理解这四种排序算法的实现细节，通过阅读和运行代码，可以更直观地感受它们的工作方式，并进一步提升C++编程技能。对于需要处理大量数据的程序，理解这些排序算法...
c++实现比较各种排序算法的效率
06-15
冒泡排序 插入排序 选择排序 快速排序 归并排序 交换排序 效率比较 代码结构清晰
算法入门＜一＞：C++各种排序算法详解及示例源码
欧特GO
04-28 1933
算法入门＜一＞：C++各种排序算法详解及示例源码
各种排序算法的C++实现与性能比较
rein07的专栏
08-25 353
排序是计算机算法中非常重要的一项，而排序算法又有不少实现方法，那么哪些排序算法比较有效率，哪些算法在特定场合比较有效，下面将用C++实现各种算法，并且比较他们的效率，让我们对各种排序有个更深入的了解。 minheap.h 用于堆排序： view sourceprint?001 //使用时注意将关键码加入 002 #ifndef MINHEAP_H 003 #defi...
用C++，C语言实现几种排序以及性能对比（sort，qsort，冒泡）
ECNUACRush的博客
03-08 646
性能测试： /* * 文件名：Sort_efficiency_test.cpp * 版权：Copyright 2000-2001 Huawei Tech. Co. Ltd. All Rights Reserved. * 描述： 各种排序性能测试 * 修改人：EcnuAcRUSH * 修改时间：2001-02-16 */ #include <iostream> #include &lt...
排序法比较（C++）
Shunrei的专栏
05-20 974
一、程序设计的基本思路：1、冒泡排序算法：起泡排序就是把小的元素往前调或者把大的元素往后调。比较的是相邻的两个元素的大小，交换也发生在这两个相邻元素之间。2、选择排序算法：选择排序是给每个位置选择当前元素最小的，比如给第一个位置选择最小的，在剩余元素里面给第二个元素选择第二小的，依次类推，直到第n-1个元素，第n个元素不用选择了，因为只剩下它一个最大的元素了。3、插入排序算法：插入排序
七种排序算法 C++ 实现及性能分析
weixin_51068265的博客
06-29 497
七种排序算法 C++ 实现及性能分析
实验9 排序算法实验比较
qq_45755193的博客
01-10 1594
排序算法实验比较（实验报告） 一、源码编写与调试 | 时间：2021.1.2 | 实验完成度：40% | 实验目的： 基于教材内容，选择直接插入排序和归并排序两种排序算法，实现并比较其性能。 实验过程： 1.先随机生成数据规模分别为100，1K，10K，100K和1M的5个TXT文件，用于排序的测试。 2.对源码进行编写，熟悉文件流操作和C++的微秒定时操作。 3.对源码进行编译，对于不同数据规模的数据，使用直接插入排序算法和归并排序算法各进行处理，将排序结果输出到文件中，且在屏幕上输出排序过程所花费时间
C++基本序列式容器效率比较
luoganttcc的博客
11-18 784
前面介绍序列式的三种容器时，我们简单介绍了在容器各部位插入或删除元素时的处理效率，在此节我们做一个总结。 根据 STL 公布的容器各种操作效率，我们可以根据不同的需求来选择合适的容器。例如，我们需要频繁的在容器的任意位置插入或删除元素，则我们可以选择 list，而非 vector 和 deque。具体的总结见下表。 基本操作 vector deque list 在容器头部插入或删除元素 线性 恒定 恒定 在容器尾部插入或删除元素 恒定 恒定 恒定 在容器中部插入或删除元素 线性 线性
受够了初级排序算法，今天来个效率高的——归并排序。
khabibzgl的博客
09-10 608
排序算法之归并排序 前情回顾： 在前几篇文章中我们学习了选择排序，插入排序，以及插入排序的优化版希尔排序，但是他们的时间复杂度都是O(N^2)，现在我们终于迎来了我们算法效率大幅度提升的，时间复杂度为O(NlogN)算法——归并排序。 基本概念： 归并排序的具体含义就是合并两个有序的数组，使数组合并成为一个数组，并且合成的这一个数组整个内部都是有序的。当我们有了这个归并的算法之后，我们就可以用递归来把整个数组一分为二，二分为四，以此类推。最终我们会得到很小的数组。把这些小数组合并为有序的，最终我们就会得到整
排序算法实验：C++实现与性能检验
这个实验文档不仅提供了一种排序算法的实现，还为学习者提供了实践和理解其他排序算法（如冒泡排序、选择排序、快速排序等）的基础，帮助他们深入理解排序算法的原理和性能。通过实际编写和运行这些代码，学生可以更...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值