九大基础排序算法详解，效率对比

最新推荐文章于 2026-04-19 04:50:20 发布
原创 最新推荐文章于 2026-04-19 04:50:20 发布 · 1.2k 阅读 · 6 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
收录于
c++

当前文章被收录于：

c++
6 篇文章 1 人学习
订阅专栏 查看详情
博客介绍了九大排序算法，包括插入、希尔、冒泡等。阐述了排序算法可分为内部和外部排序，还提及各算法的时间复杂度和稳定性。通过对100个1到10000的数排序30000次，对比了各大算法效率，同时给出了各算法源代码。

九大排序效率对比

九大算法基础简介

排序算法可以分为内部排序和外部排序，内部排序是数据记录在内存中进行排序，而外部排序是因排序的数据很大，一次不能容纳全部的排序记录，在排序过程中需要访问外存。常见的内部排序算法有：插入排序、希尔排序、选择排序、冒泡排序、归并排序、快速排序、堆排序、基数排序等。用一张图概括：在这里插入图片描述
在这里插入图片描述关于时间复杂度

平方阶 (O(n2)) 排序 各类简单排序：直接插入、直接选择和冒泡排序。

线性对数阶 (O(nlog2n)) 排序 快速排序、堆排序和归并排序；

O(n1+§)) 排序，§ 是介于 0 和 1 之间的常数。 希尔排序

线性阶 (O(n)) 排序 基数排序，此外还有桶、箱排序。

关于稳定性

稳定的排序算法：冒泡排序、插入排序、归并排序和基数排序。

不是稳定的排序算法：选择排序、快速排序、希尔排序、堆排序。

名词解释：

  • n：数据规模
  • k："桶"的个数
  • In-place：占用常数内存，不占用额外内存
  • Out-place：占用额外内存
  • 稳定性：排序后 2 个相等键值的顺序和排序之前它们的顺序相同

运行程序后各大算法效率对比

在这里插入图片描述
待排序的100个1到10000的数，排序30000次

各个算法源代码

mian函数：

在这里插入图片描述

冒泡排序

template<class T>
void BubbleSort(vector<T>& x)
{
	bool flag = true;
	for (unsigned i = 0; i < x.size() && flag; i++) {
		flag = false;
		for (unsigned k = 1; k < x.size(); k++) {
			if (x[k] < x[k - 1]) {
				T temp = x[k];
				x[k] = x[k - 1];
				x[k - 1] = temp;
				flag = true;
			}
		}
	}
}

选择排序

template<class T>
void SelectSort(vector<T>& x)
{
	T temp;
	for (unsigned i = 0; i < x.size(); i++) {
		int minNumIndex = i;
		for (unsigned k = i + 1; k < x.size(); k++) {
			if (x[minNumIndex] > x[k]) {
				minNumIndex = k;
			}
		}
		if (minNumIndex != i) {
			temp = x[minNumIndex];
			x[minNumIndex] = x[i];
			x[i] = temp;
		}
	}
}

插入排序

template<class T>
void InsertSort(vector<T>& x)
{
	T temp;
	for (unsigned i = 0; i < x.size(); i++) {
		for (unsigned k = i + 1; k < x.size(); k++) {
			if (x[i] > x[k]) {
				temp = x[k];
				x[k] = x[i];
				unsigned p = i;
				while (x[p] < temp && p>1) {
					x[p] = x[p - 1];
				}
				x[p] = temp;
			}
		}
	}
}

希尔排序

template<class T>
void ShellSort(vector<T>& x)
{
	int Length = x.size();
	for (int gap = Length / 2; gap > 0; gap /= 2) {
		for (int i = gap; i < Length; i++) {
			T inserted = x[i];//此时待插入的数
			int j;
			for (j = i - gap; j >= 0 && inserted < x[j]; j -= gap) {
				x[j + gap] = x[j];//将当前j位置的值移到gap后的位置
			}
			x[j + gap] = inserted;
		}
	}
}

计数排序

template<class T>
void ShellSort(vector<T>& x)
{
	int Length = x.size();
	for (int gap = Length / 2; gap > 0; gap /= 2) {
		for (int i = gap; i < Length; i++) {
			T inserted = x[i];//此时待插入的数
			int j;
			for (j = i - gap; j >= 0 && inserted < x[j]; j -= gap) {
				x[j + gap] = x[j];//将当前j位置的值移到gap后的位置
			}
			x[j + gap] = inserted;
		}
	}
}

基数排序

template<class T>
void RadixSort(vector<T>& x)
{
	int* count = new int[10]; //计数器
	int raidx = 1;
	int k;
	int index = 0;
	vector<vector<T>>xArray;//创建十个容器
	vector<T> xx;
	for (int i = 0; i < 10; i++) {
		xArray.push_back(xx);
	}
	//得到最大位数
	T maxNum = x[0];
	int weishu = 1;
	for (int i = 1; i < x.size(); i++) {
		if (maxNum < x[i]) { maxNum = x[i]; }
	}
	while (maxNum > 10) {
		weishu++;
		maxNum /= 10;
	}
	for (int j = 0; j < weishu; j++) {//进行weishu次排序
		for (unsigned i = 0; i < x.size(); i++) {
			k = (x[i] / raidx) % 10;//统计每个桶中的记录数
			xArray[k].push_back(x[i]);
		}
		for (unsigned i = 0; i < xArray.size(); i++) {
			for (unsigned p = 0; p < xArray[i].size(); p++) {
				x[index] = xArray[i][p];//将是个容器中的值重新整合到 x中
				index++;
			}
		}
		for (unsigned i = 0; i < xArray.size(); i++) {
			xArray[i].clear();
		}
		raidx *= 10;
		index = 0;
	}
}

二叉树排序

template<class T>
void BSTSort(vector<T>& x)
{
	BST<int>bst(x);
	x = bst.sortToVector();
}

二叉树源码：

#pragma once
#include<iostream>
#include<map>
#include <iomanip>
#include<queue>
using namespace std;
template<typename DataType>
class BST
{
private:
	/**********数据成员*********/
	class BinNode {
	public:
		DataType data;
		BinNode* left;
		BinNode* right;
		BinNode() :left(0), right(0) {}//data默认初始化为DataType类型值，两条链为空
		BinNode(DataType item) :data(item), left(0), right(right) {}//data初始化，其他两条链为空
	};
	typedef BinNode* BinNodePointer;
	BinNodePointer myRoot;//根节点
	void inorderAux(ostream& out, BST<DataType>::BinNodePointer subtreeptr)const;
	void foreOrderAux(ostream& out, BST<DataType>::BinNodePointer subtreeptr)const;
	void afterOrderAux(ostream& out, BST<DataType>::BinNodePointer subtreeptr)const;
	void deleteAux(const DataType& item, bool& found, BST<DataType>::BinNodePointer& locptr, BST<DataType>::BinNodePointer& parent)const;
	void BSTAux(BST<DataType>::BinNodePointer& ptr);
	void horizontalGraphAux(ostream& out, int indent, BST<DataType>::BinNodePointer subtreeRoot)const;//打印
	void verticalGraghAux(BST<DataType>::BinNodePointer ptr, vector<DataType>& elementVector)const;
	void SortAux(BST<DataType>::BinNodePointer subtreeptr, vector<DataType>& v)const;//排序辅助函数
public:
	/**********成员函数*********/
	BST();
	//构建空的BST
	BST(vector<DataType>v);
	~BST();//析构函数
	bool empty();//判断BST是否为空,空则返回1
	void add(const DataType& item);//节点的添加函数
	void inorder(ostream& out)const;//中序输出
	void foreorder(ostream& out)const;//前序输出
	void afterOrder(ostream& out)const;//前序输出
	void levelorder(ostream& out)const;//层次遍历输出
	void Delete(const DataType& item);//删除节点
	void graphHorizontal(ostream& out)const;//打印
	void graphVertical(ostream& out)const;//打印
	vector<DataType> sortToVector()const;//排序
};

template<typename DataType>
inline BST<DataType>::BST() :myRoot(0) {}

template<typename DataType>
inline BST<DataType>::BST(vector<DataType> v)
{
	for (int i = 0; i < v.size(); i++) {
		this->add(v[i]);
	}

}

template<typename DataType>
inline BST<DataType>::~BST()
{
	if (myRoot != 0) {
		BSTAux(myRoot->left);
		BSTAux(myRoot->right);
		delete myRoot;
	}
}

template<typename DataType>
bool inline BST<DataType>::empty()
{
	return myRoot == 0;
}

template<typename DataType>
inline void BST<DataType>::add(const DataType& item)
{
	BST<DataType>::BinNodePointer ptr = myRoot, parent = 0;
	while (ptr != 0) {
		parent = ptr;
		if (item < ptr->data) {//下降到左子树
			parent = ptr;
			ptr = ptr->left;
		}
		else if (item >= ptr->data) {//下降到右子树
			parent = ptr;
			ptr = ptr->right;
		}
	}
	ptr = new BST<DataType>::BinNode(item);
	if (parent == 0) {
		myRoot = ptr;
	}
	else if (item < parent->data) {
		parent->left = ptr;
	}
	else {
		parent->right = ptr;
	}
}


template<typename DataType>
inline void BST<DataType>::inorder(ostream& out) const
{
	cout << "中序遍历:  ";
	inorderAux(out, myRoot);
	cout << endl;
}

template<typename DataType>
inline void BST<DataType>::foreorder(ostream& out) const
{
	cout << "前序遍历:  ";
	foreOrderAux(out, myRoot);
	cout << endl;
}

template<typename DataType>
inline void BST<DataType>::afterOrder(ostream& out) const
{
	cout << "后序遍历:  ";
	afterOrderAux(out, myRoot);
	cout << endl;
}

template<typename DataType>
inline void BST<DataType>::levelorder(ostream& out) const
{
	queue<BST<DataType>::BinNodePointer>QueueOut;
	queue<BST<DataType>::BinNodePointer>QueueStore;
	QueueOut.push(myRoot);
	QueueStore.push(myRoot);
	while (!QueueStore.empty()) {
		BST<DataType>::BinNodePointer localItem = QueueStore.front();
		QueueStore.pop();
		if (localItem->left != 0) {
			QueueOut.push(localItem->left);
			QueueStore.push(localItem->left);
		}
		if (localItem->right != 0) {
			QueueOut.push(localItem->right);
			QueueStore.push(localItem->right);
		}

	}
	out << "层次遍历:  ";
	unsigned QueueOutSize = QueueOut.size();
	for (unsigned i = 0; i < QueueOutSize; i++) {
		out << QueueOut.front()->data << " ";
		QueueOut.pop();
	}
	out << endl;
}


template<typename DataType>
inline void BST<DataType>::Delete(const DataType& item)
{
	BST<DataType>::BinNodePointer parent, x = new BinNode();
	bool found;
	deleteAux(item, found, x, parent);//进行x 和 parent的赋值
	if (!found) {
		cout << "该节点没有被找到." << endl;
		return;
	}
	else {
		cout << "待删除的数: " << item << endl;

	}
	//节点有两个子女
	if (x->left != 0 && x->right != 0) {
		//查找x的中序后继 及双亲节点(右子树的最左节点)
		BST<DataType>::BinNodePointer xSucc = x->right;
		parent = x;
		while (xSucc->left != 0) {
			parent = xSucc;
			xSucc = xSucc->left;
		}
		x->data = xSucc->data;//将xSucc中的内容移动到x中，修改x为指向被删除的后继
		x = xSucc;
	}
	//处理只有一个节点或者没有结点的情况
	BST<DataType>::BinNodePointer subtree = x->left;//指向x的子树的指针		
	if (subtree == 0) {//如果指针为空说明x的左子为空 subtree指向x的右子
		subtree = x->right;
	}
	if (parent == 0) { myRoot = subtree; }
	else if (parent->left == x) { parent->left = subtree; }
	else { parent->right = subtree; }
	delete x;
}

template<typename DataType>
inline void BST<DataType>::inorderAux(ostream& out, BST<DataType>::BinNodePointer subtreeptr) const
{
	if (subtreeptr != 0) {
		inorderAux(out, subtreeptr->left);
		out << subtreeptr->data << " ";
		inorderAux(out, subtreeptr->right);
	}
}

template<typename DataType>
inline void BST<DataType>::foreOrderAux(ostream& out, BST<DataType>::BinNodePointer subtreeptr) const
{
	if (subtreeptr != 0) {
		out << subtreeptr->data << " ";
		foreOrderAux(out, subtreeptr->left);
		foreOrderAux(out, subtreeptr->right);
	}
}

template<typename DataType>
inline void BST<DataType>::afterOrderAux(ostream& out, BST<DataType>::BinNodePointer subtreeptr) const
{
	if (subtreeptr != 0) {
		afterOrderAux(out, subtreeptr->left);
		afterOrderAux(out, subtreeptr->right);
		out << subtreeptr->data << " ";
	}
}

template<typename DataType>
inline void BST<DataType>::deleteAux(const DataType& item, bool& found, BST<DataType>::BinNodePointer& locptr, BST<DataType>::BinNodePointer& parent) const
{
	locptr = myRoot;
	parent = 0;
	found = false;
	while (!found && locptr != 0) {
		if (item < locptr->data) {
			parent = locptr;
			locptr = locptr->left;
		}
		else if (item > locptr->data) {
			parent = locptr;
			locptr = locptr->right;
		}
		else {
			found = true;
		}
	}
}

template<typename DataType>
inline void BST<DataType>::BSTAux(BST<DataType>::BinNodePointer& ptr)
{
	if (ptr != 0) {
		BSTAux(ptr->left);
		BSTAux(ptr->right);
		delete ptr;
	}
}

template<typename DataType>
inline void BST<DataType>::graphHorizontal(ostream& out) const
{
	horizontalGraphAux(out, 0, myRoot);
}

template<typename DataType>
inline void BST<DataType>::horizontalGraphAux(ostream& out, int indent, BST<DataType>::BinNodePointer subtreeRoot) const
{
	if (subtreeRoot != 0) {
		horizontalGraphAux(out, indent + 8, subtreeRoot->right);
		out << setw(indent) << " " << subtreeRoot->data << endl;
		//setw当后面紧跟着的输出字段长度小于 n 的时候，在该字段前面用空格补齐，当输出字段长度大于 n 时，全部整体输出。
		horizontalGraphAux(out, indent + 8, subtreeRoot->left);
	}
}

template<typename DataType>
inline void BST<DataType>::verticalGraghAux(BST<DataType>::BinNodePointer ptr, vector<DataType>& elementVector)const
{
	if (ptr != 0) {
		verticalGraghAux(ptr->left, elementVector);
		elementVector.push_back(ptr->data);
		verticalGraghAux(ptr->right, elementVector);
	}
}

template<typename DataType>
inline void BST<DataType>::SortAux(BST<DataType>::BinNodePointer subtreeptr, vector<DataType>& v) const
{
	if (subtreeptr != 0) {
		SortAux(subtreeptr->left, v);
		v.push_back(subtreeptr->data);
		SortAux(subtreeptr->right, v);
	}
}

template<typename DataType>
inline void BST<DataType>::graphVertical(ostream& out) const
{
	vector<DataType> v;
	verticalGraghAux(myRoot, v);
	queue<BST<DataType>::BinNodePointer> q;
	q.push(myRoot);
	while (!q.empty()) {
		vector<BST<DataType>::BinNodePointer> cache;
		//把处在同一行的节点拉出来
		while (!q.empty()) { cache.push_back(q.front()); q.pop(); }
		map<DataType, int> elementMap;
		for (auto p : cache) {
			if (p) {
				//找当前节点中序遍历位置
				typename vector<DataType>::iterator iter;
				iter = find(v.begin(), v.end(), p->data);
				int index = iter - v.begin();
				elementMap.insert(pair<DataType, int>(p->data, index));
				//孩子节点入队
				if (p->left) q.push(p->left);
				if (p->right) q.push(p->right);
			}
		}
		typename map<DataType, int>::iterator iter;
		int gap = 0;
		for (iter = elementMap.begin(); iter != elementMap.end(); iter++)
		{
			for (int i = 0; i < iter->second - gap; i++) {
				out << " ";
			}
			cout << iter->first;
			gap = iter->second;
		}
		out << endl;
	}

}
template<typename DataType>
inline vector<DataType> BST<DataType>::sortToVector() const
{
	vector<DataType> v1;
	SortAux(myRoot, v1);
	return v1;
}
#pragma once

快排

template<class T>
void QuickSort(vector<T>& x, int first, int last)
{
	int pos = 0;
	if (first < last) {
		pos = split(x, first, last);
		QuickSort(x, first, pos - 1);
		QuickSort(x, pos + 1, last);
	}
}
template<class T>
int split(vector<T>& x, int first, int last)
{
	T pivot = x[first];
	int left = first,//序列开始头部
		right = last;//序列开始尾部
	while (left < right) {//结束条件为标记头和标记尾碰到一起
		while (pivot < x[right]) {
			//从从右往左开始，为何？
			//因为如果从左往右 该序列有序且服从从小到大，则left会一直++，直至越界报错
			right--;
		}
		while (left < right && (x[left] <= pivot)) {
			//如果做标记没有碰到右标记，且当前左标记所在的值小于pivot
			left++;
		}
		if (left < right) {//交换左标记点和右标记点的值
			int temp = x[left];
			x[left] = x[right];
			x[right] = temp;
		}
	}
	//左标记点和有标记点碰到一起，交换pivot和左右标记点所在点的值
	int pos = right;
	x[first] = x[pos];
	x[pos] = pivot;
	return pos;//返回当前界值
}

堆排序

template<class T>
void HeapSort(vector<T>& x)
{
	int count = 0;
	makeHeapify(x);//进行建堆，x[i]必大于x[i*2]和x[i*2+1]
	for (int i = x.size() - 1; i >= 2; i--) {
		//进行根叶交换
		T temp = x[i];
		x[i] = x[1];
		x[1] = temp;
		//进行下调
		percolate_down(1, i - 1, x);
	}
}

//建堆算法
template<class T>
void makeHeapify(vector<T>& x) {
	int n = x.size() - 1;
	for (int i = n / 2; i >= 1; i--) {
		percolate_down(i, n, x);//对i为根的子树进行下调算法
	}

}
//下调算法(只有x[index]中的值不满足堆次序条件，把这个近似堆调整成堆)
template<class T>
void percolate_down(int index, int last, vector<T>& x) {
	int c = index * 2;
	int n = last;
	bool flag = false;
	while (c <= n && !flag) {//c是左子节点的位置
		if (c < n && x[c] < x[c + 1]) {//如果index有两个子节点并且右子节点比较大
			c++;
		}
		if (x[index] < x[c]) {//双亲节点不满足堆次排序
			T temp = x[index];
			x[index] = x[c];
			x[c] = temp;

			index = c;//可能弄乱了以c为根的二叉树，检查其下的二叉树
			c = 2 * c;
		}
		else {
			flag = true;//条件满足，结束循环
		}
	}
}
//上调算法，在其中添加一个元素，并使得排序仍然满足是一个堆
template<class T>
void percolate_up(vector<T>& x, T item) {
	x.push_back(item);
	bool flag = false;
	int itemLocation = x.size() - 1;
	int parentLocation = itemLocation / 2;
	while (parentLocation >= 1 && !flag) {
		if (x[parentLocation] < x[itemLocation]) {
			T temp = x[parentLocation];
			x[parentLocation] = x[itemLocation];
			x[itemLocation] = temp;
			itemLocation = parentLocation;
			parentLocation /= 2;
		}
		else { flag = true; }
	}
}

运行结果

在这里插入图片描述

本系列算法开篇内容整理自：https://www.runoob.com/w3cnote/ten-sorting-algorithm.html
其余内容为数据结构相关内容自行编程
排序算法是《数据结构与算法》中最基本的算法之一。

标签
#算法 #二叉树 #数据结构 #排序算法 #c++
数据结构-各种排序算法效率对比图
tanggod的专栏
02-13 1万+
排序法 平均时间复杂度 最差情形 稳定度 额外空间 备注 冒泡排序 O(n2)  O(n2) 稳定 O(1) n小时较好 交换排序 O(n2)  O(n2) 不稳定 O(1) n小时较好 选择排序 O(n2) O(n2) 不稳定 O(1) n小时较好 插入排序 O(n2) O(n2) 稳定 O(1) 大部分已
九大经典算法
工宗浩生财指南针
04-05 4669
while (i < j && [temArr[j] intValue] >= [key intValue]) { // 右边j位大于基数位置不变。if (i == j) { // i、j位置重合结束本次循环，当key是目前最小的数时，会出现i=j的情况，arr[i] = key // i和j重合时本轮循环结束，将key放入i的位置（则左侧数都比key小，右侧数都比key大）if (i == j) { // 当key是目前最大的数时(m[j]的前面)，会出现i=j的情况。未排序元素继续重复排序操作。
STM32F030 IAP实战：当Cortex-M0没有VTOR寄存器时，我是这样搞定中断向量表重映射的
最新发布
weixin_30527323的博客
04-19 179
本文详细介绍了在STM32F030 Cortex-M0芯片上实现IAP功能时，如何解决中断向量表重映射的问题。由于Cortex-M0没有VTOR寄存器，作者通过SRAM重映射技术成功实现了中断响应，并分享了完整的代码实现、内存布局调整方案以及实战中遇到的五个典型问题及其解决方案。
简单选择，冒泡，插入，快速排序之效率比较
fenfei_zqh的博客
01-23 1998
简单选择，冒泡，插入，快速排序之效率比较 这四种耳熟能祥的排序算法，找了个时间自己去重写研究了一遍，考察了他们的运行效率问题。当然对于一些初级的程序员千万别在拿着选择排序当冒泡排序的用了。所有的排序都是根据自己对排序思想的理解后编写的，如有不正确的地方还请提出。 简单选择排序：每次从数组序列中选择一个元素与其他所有元素进行比较，每趟可以确定序列中最小的元素。 public static vo
java 快速排序_JAVA面试题：5分钟了解快速排序
weixin_39958248的博客
12-02 358
前言快速排序是面试中经常会问到的一种排序算法，对比其他一些排序算法，快速排序的平均时间相对较少。快速排序思想介绍快速排序使用了分治的思想，通过一轮的排序，可以将序列分割成独立的两个部分，其中一部分的值均比基准值小，另一部分的值均比基准值大。而后针对两部分序列再分别按照同样的算法进行排序，直到序列整体有序。以如下序列arr为例进行升序排序，说明快速排序的基本算法第一个位置的值23作为基准值base，...
各种排序算法的稳定性及效率比较
Cottage驿站
05-15 2843
1.稳定性比较 1） 稳定的：如果存在多个具有相同排序码的记录，经过排序后，这些记录的相对次序仍然保持不变，则这种排序算法称为稳定的。     插入排序、冒泡排序、归并排序、分配排序（桶式、基数）都是稳定的排序算法。2）不稳定的：否则称为不稳定的。直接选择排序、堆排序、shell排序、快速排序都是不稳定的排序算法。 插入排序、冒泡排序、二叉树排序、二路归并排序及其他线形排序是稳定的选择排序、希尔排
九大排序算法总结
热门推荐
楚兴
02-15 1万+
九大排序算法实现 插入排序算法实现 希尔排序算法实现 选择排序算法实现 冒泡排序算法实现 归并排序算法实现 快速排序算法实现 堆排序算法实现 基数排序算法实现
C语言实现九大排序算法
爱敲代码的三毛的博客
12-27 3285
排序算法
九大常见排序算法
qq_45841205的博客
06-03 1223
九大常见排序算法排序算法一：冒泡排序算法排序算法二：选择排序排序算法三：插入排序排序算法四：希尔排序排序算法五：归并排序 排序算法一：冒泡排序算法 基本思想：n个数比较n-1轮，第一轮有n个数，但是由于是两两比较，所以只用比较n-1次；第二轮由于前一轮结束后，最大（最小）的数已经方法第n-1位了，所以只用再比较剩下的n-1个数，要比较n-2次；以此类推，那么第i轮就要比较n-i次，所以代码为： import java.util.Arrays; public class Main { public s
九大排序算法
F13253524870的博客
04-19 1308
排序算法可以分为内部排序和外部排序，内部排序是数据记录在内存中进行排序，而外部排序是因排序的数据很大，一次不能容纳全部的排序记录，在排序过程中需要访问外存。 常见的内部排序算法有：插入排序、希尔排序、选择排序、冒泡排序、归并排序、快速排序、堆排序、基数排序等。 算法一、直接插入排序 直接插入排序的思想是每次将一个待排序的记录按照关键字大小的顺序插入到前面已经排好序的子序列中，直到全部记录插入完成,下面是一个排序的示例。 直接插入排序的代码： 第一种写法： public void insertSort(
九大排序算法原理图解
weixin_42213176的博客
01-09 4120
0.稳定性和复杂度 开始之前，先简单介绍一下排序算法的几个重要指标,这里，我尽量用自己理解的傻瓜式方法解读： （1）稳定性：当序列中存在两个或两个以上的关键字相等的时候，如果排序前序列中r1领先于r2,那么排序后r1如果仍旧领先r2的话，则是稳定的。（相等的元素排序后相对位置不变） （2）不稳定性：当序列中存在两个或两个以上的关键字相等的时候，如果排序前序列中r1领先于r2,那么排序后r1如果落后...
九大常用排序算法（C++版）
weixin_53026694的博客
09-09 254
排序算法（sorting algorithm）用于对一组数据按照特定顺序进行排列。排序算法有着广泛的应用，因为有序数据通常能够被更有效地查找、分析和处理。
动画图解：九大经典排序算法详解-算法宝App
caihuadi的专栏
03-30 1282
时间复杂度(time complexity)用来描述算法的运行时间。常用大O符号表述。比如：O(n)，O(1)，O(logn)，O(n2)等。举例：O(n)表示线性级复杂度，表示时间复杂度和元素element数量n成正比。比如数组的线性查找的复杂度随着元素数量增加而增加。O(1)表示常数级复杂度，表示时间复杂度不随元素element数量变化而变化。比如链表的插入的复杂度不随链表节点数量变化而变化。其他常见的复杂度如下图所示：空间复杂度(Space Complexity)
九大排序算法（c语言版）
m0_75233418的博客
02-16 1991
过年这几天晚上在家码代码学了一点。代码中排序的数字均由rand()函数随机生成。
九大排序算法联系与分析
qq_44733706的博客
03-17 747
九大排序算法设计与分析 一切问题的解决都有其相应的方法论做指导。作为程序设计的基本问题，排序算法经过发展已经有了较为成熟的解决方案。排序算法看似简单但是其中却蕴含着算法设计的基本思想。各个排序算法不是孤立的，他们是在科学的理论框架下的产物。本文以排序算法为媒介，通过学习排序算法，掌握分析问题和解决问题的基本思路。 编程论到极致，核心非代码，即思想 排序定义: 排序是计算机内经常进行的一种...
动画图解：九大经典排序算法详解（算法宝App）
caihuadi的专栏
03-29 1725
时间复杂度(time complexity)用来描述算法的运行时间。常用大O符号表述。比如：O(n)，O(1)，O(logn)，O(n2)等。举例：O(n)表示线性级复杂度，表示时间复杂度和元素element数量n成正比。比如数组的线性查找的复杂度随着元素数量增加而增加。O(1)表示常数级复杂度，表示时间复杂度不随元素element数量变化而变化。比如链表的插入的复杂度不随链表节点数量变化而变化。其他常见的复杂度如下图所示：空间复杂度(Space Complexity)
九大基础排序总结与对比 转自http://blog.csdn.net/amazing7/article/details/51603682
Foxz的博客
08-08 1076
九大基础排序总结与对比 标签： 数据结构排序算法九大排序 2016-06-07 15:43 12646人阅读 评论(6) 收藏 举报  分类： data structure 版权声明：本文为博主原创文章，未经博主允许不得转载。 目录(?)[+] 请尊重个人劳动成果，转载注明出处，谢谢！  http://bl
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值