常见排序算法性能分析比较（快排，希尔，堆排，归并，插入排序等）

最新推荐文章于 2022-02-06 10:09:18 发布
最新推荐文章于 2022-02-06 10:09:18 发布
阅读量4.2k 收藏 21
点赞数 3
分类专栏： C语言 数据结构 文章标签： 排序算法 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/S5242/article/details/114357466
版权

文章目录

1.各种排序算法实现及其特点

在这里插入图片描述

1.1 直接插入排序

直接插入排序的特性总结：

  1. 元素集合越接近有序，直接插入排序算法的时间效率越高
  2. 时间复杂度：O(N^2)
  3. 空间复杂度：O(1)，它是一种稳定的排序算法
  4. 稳定性：稳定

void Swap(int* a, int* b)
{
	int tmp = *a;
	*a = *b;
	*b = tmp;
}
//直接插入排序-从前往后比较
void InsertSort_1(int* ar, int left, int right)
{
	for (int i = left + 1; i < right; ++i)
	{
		int k = left;
		while (ar[i] > ar[k])
			k++;

		int tmp = ar[i];
		for (int j = i; j > k; --j)
			ar[j] = ar[j - 1];

		ar[k] = tmp;
	}
}
//直接插入排序-从后往前比较
void InsertSort_2(int* ar, int left, int right)
{
	for (int i = left + 1; i < right; ++i)
	{
		int j = i;
		while (j > left && ar[j] < ar[j - 1])
		{
			Swap(&ar[j], &ar[j - 1]);
			j--;
		}
	}
}

//直接插入排序-从后往前比较不调用交换函数
void InsertSort_3(int* ar, int left, int right)
{
	for (int i = left + 1; i < right; ++i)
	{
		int j = i;
		int tmp = ar[j];
		while (j > left && tmp < ar[j - 1])
		{
			ar[j] = ar[j - 1];
			j--;
		}

		ar[j] = tmp;
	}
}

//直接插入排序-哨兵位
void InsertSort_4(int* ar, int left, int right)
{
	for (int i = left + 1; i < right; ++i)
	{
		ar[0] = ar[i];  //哨兵位
		int j = i;
		while (ar[0] < ar[j - 1])
		{
			ar[j] = ar[j - 1];
			j--;
		}
		ar[j] = ar[0];
	}
}
//折半插入排序
void BinInsertSort(int* ar, int left, int right)
{
	for (int i = left + 1; i < right; ++i)
	{
		int tmp = ar[i];
		int low = left;
		int high = i - 1;
		int mid;
		while (low <= high)  //折半查找插入位置
		{
			mid = (low + high) / 2;
			if (tmp >= ar[mid])
				low = mid + 1;
			if (tmp < ar[mid])
				high = mid - 1;
		}

		for (int j = i; j > low; --j)
			ar[j] = ar[j - 1];

		ar[low] = tmp;
	}
}


//二路插入排序   空间复杂度 O(n)
void TwoWayInsertSort(int* ar, int left, int right)
{
	int n = right - left;
	int* tmp = (int*)malloc(sizeof(int) * n);

	tmp[0] = ar[left];
	int first, final;
	first = final = 0;
	for (int i = left + 1; i < right; ++i)
	{
		if (ar[i] < tmp[first])
		{
			first = (first - 1 + n) % n;
			tmp[first] = ar[i];
		}
		else if (ar[i] >= tmp[final])
		{
			tmp[++final] = ar[i];
		}
		else
		{
			int end = final;
			while (ar[i] < tmp[end])
			{
				tmp[(end + 1) % n] = tmp[end];
				end = (end - 1 + n) % n;
			}
			tmp[(end + 1) % n] = ar[i];
			final++;
		}
	}

	int k = 0;
	for (int i = first; k < n; ++k)
	{
		ar[k] = tmp[i];
		i = (i + 1) % n;
	}
	free(tmp);
}

1.2 希尔排序

希尔排序的特性总结：

  1. 希尔排序是对直接插入排序的优化。
  2. 当gap > 1时都是预排序，目的是让数组更接近于有序。当gap == 1时，数组已经接近有序的了，这样就
    会很快。这样整体而言，可以达到优化的效果。我们实现后可以进行性能测试的对比。
  3. 希尔排序的时间复杂度不好计算，需要进行推导，推导出来平均时间复杂度： O(N1.3—N2）
  4. 稳定性：不稳定。


void ShellSort(int* ar, int left, int right)
{
	int gap = right - left;
	while (gap > 1)
	{
		gap = gap / 3 + 1; //4  2  1  设计文档
		for (int i = left + gap; i < right; ++i)
		{
			if (ar[i] < ar[i - gap])
			{
				int tmp = ar[i];
				int j = i;
				while (j > left && tmp < ar[j - gap])
				{
					ar[j] = ar[j - gap];
					j = j - gap;
				}

				ar[j] = tmp;
			}
		}
	}
}

1.3 直接选择排序

直接选择排序的特性总结：

  • 直接选择排序思考非常好理解，但是效率不是很好。实际中很少使用
  • 时间复杂度：O(N^2)
  • 空间复杂度：O(1)
  • 稳定性：不稳定

void Swap(int* a, int* b)
{
	int tmp = *a;
	*a = *b;
	*b = tmp;
}
//简单选择排序

int GetMinIndex(int* ar, int left, int right)
{
	int min_value = ar[left];
	int index = left;

	for (int i = left + 1; i < right; ++i)
	{
		if (ar[i] < min_value)
		{
			min_value = ar[i];
			index = i;
		}
	}
	return index;
}

void SelectSort(int* ar, int left, int right)
{
	for (int i = left; i < right - 1; ++i)
	{
		int index = GetMinIndex(ar, i, right);
		if (index != i)
			Swap(&ar[i], &ar[index]);
	}
}

1.4 堆排序

堆排序：需要注意的是排升序要建大堆，排降序建小堆。

  • 堆排序使用堆来选数，效率就高了很多。
  • 时间复杂度：O(N*logN)
  • 空间复杂度：O(1)
  • 稳定性：不稳定
//堆排  这里是升序排列 建立大堆  需要向下调整
void _AdjustDown(int* ar, int left, int right, int start)
{
	int n = right - left;
	int i = start;    //代表父节点
	int j = 2 * i + 1;  //代表i节点的左子树

	int tmp = ar[i];

	while (j < n)
	{
		if (j + 1 < n && ar[j] < ar[j + 1])
			j = j + 1;

		if (tmp < ar[j])
		{
			ar[i] = ar[j];
			i = j;
			j = 2 * i + 1;
		}
		else
			break;
	}

	ar[i] = tmp;
}
void HeapSort(int* ar, int left, int right)
{
	int n = right - left;
	int curpos = n / 2 - 1 + left; //找到二叉树的最后一个分支
	while (curpos >= 0)
	{
		_AdjustDown(ar, left, right, curpos);
		curpos--;
	}

	//排序
	int end = right - 1;
	while (end > left)
	{
		Swap(&ar[left], &ar[end]); //出堆
		_AdjustDown(ar, left, end, 0);
		end--;
	}
}

1.5 冒泡排序

冒泡排序的特性总结：

  • 冒泡排序是一种非常容易理解的排序
  • 时间复杂度：O(N^2)
  • 空间复杂度：O(1)
  • 稳定性：稳定
//冒泡排序
void BubbleSort_1(int* ar, int left, int right)
{
	for (int i = left; i < right - 1; ++i)
	{
		for (int j = left; j < right - i - 1; ++j)
		{
			if (ar[j] > ar[j + 1])
			{
				Swap(&ar[j], &ar[j + 1]);
			}
		}
	}
}
//改进  无交换时可以退出循环
void BubbleSort_2(int* ar, int left, int right)
{
	bool is_swap = false;
	for (int i = left; i < right - 1; ++i)
	{
		for (int j = left; j < right - i - 1; ++j)
		{
			if (ar[j] > ar[j + 1])
			{
				Swap(&ar[j], &ar[j + 1]);
				is_swap = true;
			}
		}
		if (!is_swap)
			break;
		else
			is_swap = false;
	}
}

1.6 快速排序

快速排序：
实现方法常有三种：

1. hoare版本
2. 挖坑法
3. 前后指针版本

代码实现均有。
特点：
1. 快速排序整体的综合性能和使用场景都是比较好的，所以才敢叫快速排序
2. 时间复杂度：O(N*logN)
3. 空间复杂度：O(logN)
4. 稳定性：不稳定

//快速排序
int GetMidIndex(int* ar, int left, int right)
{
	int mid = (left + right - 1) / 2;
	if (ar[left] < ar[mid] && ar[mid] < ar[right - 1])
		return mid;
	if (ar[left] > ar[mid] && ar[left] < ar[right - 1])
		return left;
	return right - 1;
}

//hoare 法
int _Partition_1(int* ar, int left, int right)
{
	int low = left, high = right - 1;
	int key = ar[low];
	while (low < high)
	{
		while (low<high && ar[high]>key)
			high--;
		Swap(&ar[low], &ar[high]);

		while (low < high && ar[low] <= key)
			low++;
		Swap(&ar[low], &ar[high]);
	}
	return low;
}
//挖坑法
int _Partition_2(int* ar, int left, int right)
{
	int low = left, high = right - 1;
	int key = ar[low];
	while (low < high)
	{
		while (low<high && ar[high]>key)
			high--;
		ar[low] = ar[high];
		while (low < high && ar[low] <= key)
			low++;
		ar[high] = ar[low];
	}
	ar[low] = key;
	return low;  //曲轴点
}
//前后指针法
int _Partition_3(int* ar, int left, int right)
{
	int mid_index = GetMidIndex(ar, left, right);   //前中后三者取中间值作为用来比较的值
	if (mid_index != left)
		Swap(&ar[mid_index], &ar[left]);
	///

	int key = ar[left];
	int pos = left;
	for (int i = pos + 1; i < right; ++i)
	{
		if (ar[i] < key)
		{
			pos++;
			if (pos != i)
			{
				Swap(&ar[pos], &ar[i]);
			}
		}
	}
	Swap(&ar[left], &ar[pos]);
	return pos;
}

#define M 5     

void QuickSort(int* ar, int left, int right)
{
	if (left >= right)
		return;

	if (right - left <= M) //改进   这里元素个数少的时候 选择插入排序
		InsertSort_3(ar, left, right);
	else
	{
		int pos = _Partition_3(ar, left, right);
		QuickSort(ar, left, pos);    // 左子序列
		QuickSort(ar, pos + 1, right); // 右子序列
	}
}

1.7 归并排序

归并排序的特性总结：

  • 归并的缺点在于需要O(N)的空间复杂度，归并排序的思考更多的是解决在磁盘中的外排序问题。
  • 时间复杂度：O(N*logN)
  • 空间复杂度：O(N)
  • 稳定性：稳定
//归并排序
void _MergeSort(int* ar, int left, int right, int* tmp)
{
	if (left >= right)
		return;
	int mid = (left + right) / 2;
	_MergeSort(ar, left, mid, tmp); // 分解左边分支
	_MergeSort(ar, mid + 1, right, tmp); //分解右边分支

	//开始归并
	int begin1, end1, begin2, end2;
	begin1 = left, end1 = mid;
	begin2 = mid + 1, end2 = right;

	int k = left; //
	while (begin1 <= end1 && begin2 <= end2)
	{
		if (ar[begin1] < ar[begin2])
			tmp[k++] = ar[begin1++];
		else
			tmp[k++] = ar[begin2++];
	}

	while (begin1 <= end1)
		tmp[k++] = ar[begin1++];
	while (begin2 <= end2)
		tmp[k++] = ar[begin2++];

	memcpy(ar + left, tmp + left, sizeof(int) * (right - left + 1));
}

void MergeSort(int* ar, int left, int right)
{
	int n = right - left;
	int* tmp = (int*)malloc(sizeof(int) * n);

	_MergeSort(ar, left, right - 1, tmp);

	free(tmp);
}

1.8 计数排序

计数排序的特性总结：
j计数排序思想

计数排序为非比较排序:

  • 计数排序在数据范围集中时，效率很高，但是适用范围及场景有限.
  • 时间复杂度：O(MAX(N,范围))
  • 空间复杂度：O(范围)
  • 稳定性：稳定

2.排序算法复杂度及稳定性分析

排序算法复杂度及稳定性分析

排序算法复杂度及稳定性分析

S5242
关注
专栏目录
七大排序算法（插排，希尔，选择排序，堆排，冒泡，快排，归并）--图文详解
qq_52592775的博客
09-04 9004
万字长文加N多图片喂你七大排序的知识点, 让你用脚都能写出排序算法
八大排序C++完整代码（冒泡、希尔、插入、选择、快排、归并、桶、堆）
12-30
本资源提供了八大经典排序算法的C++实现，包括冒泡排序、希尔排序、插入排序、选择排序、快速排序、归并排序、桶排序以及堆排序。接下来，我们将深入探讨这些排序算法的原理、效率以及它们在C++中的实现。 1. **...
排序算法性能比较
10-19 213
所谓排序，即将原来无序的一个序列重新排列成有序的序列。 排序方法中涉及到稳定性，所谓稳定性，是指待排序的序列中有两个或两个以上相同的项，在排序前和排序后看这些相同项的相对位置有没有发生变化，如果没有发生变化，即该排序方法是稳定的，如果发生变化，则说明该排序方法是不稳定的。 如果记录中关键字不能重复，则排序结果是唯一的，那么选择的排序方法稳定与否就无关紧要了；如果关键字可以重复，则在选...
十大排序算法详解（三）排序算法的比较与性能分析
HK的博客
07-06 6189
时间复杂度与空间复杂度、排序算法的类别、排序算法的比较
常用排序算法性能全面对比
GWB_superman的专栏
07-13 1729
介绍 插入排序 直接插入排序是一种最简单的排序方法，它的基本操作是将一个记录插入到已排好的有序的表中，从而得到一个新的、记录数增1的有序表。 　　当前元素的前面元素均为有序，要插入时，从当前元素的左边开始往前找（从后往前找），比当前元素大的元素均往右移一个位置，最后把当前元素放在它应该呆的位置就行了。 时间复杂度O(N^2) 二分插入排序 插入排序方式首先需要为要插入的元素找到插入序列中合适的插入位置。通过折半（（low+high）/2=mid）的方式，凭...
排序算法的性能比较
qq_57027679的博客
02-06 312
time() 实现算法之后,下一步我们要确定一个输入模型.对于排序,在上一节里我们采用的是简单的输入的自然数组,然而要想比较两种算法的性能,我们需要更为复杂的模型. 为了比较,我们采用SortCompare类来做几次实验,使用Stopwatch来计时,下面的time()函数的任务是调用本章节中的几种常用的排序算法. SortCompare public class SortCompare { public static void main(String[] args) { Stri...
C++实现八个常用的排序算法：插入排序、冒泡排序、选择排序、希尔排序等
09-03
在本文中，我们将深入探讨C++实现的八种常见的排序算法，它们分别是插入排序、冒泡排序、选择排序、希尔排序、快速排序、归并排序、堆排序和LST基数排序。这些排序算法在计算机科学中有着广泛的应用，是理解和掌握...
七种排序（冒泡，选择，归并，堆，直接插入，直接选择，快排）的C语言实现
12-12
在编程领域，排序算法是计算机科学中的重要组成部分，特别是在数据处理和算法效率方面。以下是给定标题和描述中提到的七种排序算法的详细解释，以及它们在C语言中的实现要点。 1. 冒泡排序（Bubble Sort）： 冒泡...
五种排序算法的性能比较
10-02
五种算法分别为选择排序，冒泡排序，快速排序，归并排序和插入排序。代码不算优秀，仅供参考。
希尔排序，冒泡排序，堆排序等各种排序算法
12-07
本主题将详细探讨希尔排序、冒泡排序、堆排序等经典的排序算法，这些都是数据结构与算法学习中的核心内容，尤其对于北邮数据结构课程来说，理解并掌握这些排序方法至关重要。 1. **插入排序**： 插入排序是一种...
各种排序算法性能比较。
DOwnstairs的专栏
04-25 910
原帖 http://www.cnblogs.com/wangjiahong/p/3570465.html?utm_source=tuicool 下面是我直接做成的源码，直接可以运行。 大家可以根据需要测试 [code=csharp]using System; using System.Collections.Generic; using System.Diagnostics;
排序算法之性能分析及总结
热门推荐
Blog
04-25 1万+
一、排序算法说明 排序的定义：对一个无序的序列进行排序的过程。 输入：n个数：a1,a2,a3,…,an。 输出：n个数的排列:a1,a2,a3,…,an，使得a1&lt;=a2&lt;=a3&lt;=…&lt;=an。 排序的稳定性：相同值的节点相对位置是否会发生改变。 稳定：如果a原本在b前面，而a=b，排序之后a仍然在b的前面。 不稳定：如果a原本在b的前面，而a=b，排序之后a...
排序算法性能及选择总结
跌打滚爬中向前的专栏
10-15 2910
各种排序方法的性能比较： 排序法  平均时间 最坏情况 最好情况 稳定度 额外空间 备注 1．直接插入  O(n2) O(n2)   O(n)  稳定 O(1) 大部分已排序时较好
各种排序算法的比较
我的仓库 My Storehouse
07-12 3126
1.稳定性比较 插入排序、冒泡排序、二叉树排序、二路归并排序及其他线形排序是稳定的 选择排序、希尔排序、快速排序、堆排序是不稳定的2.时间复杂性比较 插入排序、冒泡排序、选择排序的时间复杂性为O(n2) 其它非线形排序的时间复杂性为O(nlog2n) 线形排序的时间复杂性为O(n);3.辅助空间的比较 线形排序、二路归并排序的辅助空间为O(n),其它排序的辅助空
各大排序算法的实现及性能比较哦
qjffff的博客
04-01 324
排序算法的实现及性能分析 ——（java版） 排序是对数据元素序列建立某种有序排列的过程。更确切的说，排序是把一个数据元素序列整理成按关键字递增（或递减）排列的过程。 不过首先，我们必须先解释一下关键字这个词。关键字是要排序的数据元素集合中的一个域，排序是以关键字为基准进行的。而关键字也分为主关键字和次关键字。对于要排序的数据元素集合来说，如果关键字满足数据元素值不同时，该关键字也不同，这...
各种排序算法的性能特点
weixin_40208575的博客
01-29 1818
这里只总结各种排序算法的性能特点，不含算法具体的实现 算法 是否稳定 是否为原地排序 时间复杂度 空间复杂度 备注 选择排序 否 是 N^2 1 插入排序 是 是 介于N和N^2之间 1 取决于输入元素的排列情况 希尔排序 否 是 NlogN？N^(6⁄5) 1 快速排序 否 是 NlogN lgN 运行效率由概率提供保证 三向快速排序 否 是 介于N和Nlog...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值