8大排序整理

最新推荐文章于 2024-04-30 17:02:09 发布
最新推荐文章于 2024-04-30 17:02:09 发布
阅读量245 收藏 1
点赞数
分类专栏： # 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Ga4ra/article/details/100133079
版权

文章目录

1. 交换排序

冒泡排序

最快平均最慢空间复杂度稳定性复杂性
o(n)o(n2)o(n2)o(1)稳定简单

冒泡排序是一种用时间换空间的排序方法

最坏情况是把顺序的排列变成逆序，或者把逆序的数列变成顺序，最差时间复杂度O(N^2)只是表示其操作次数的数量级。

最好的情况是数据本来就有序，复杂度为O(n)

#include <stdlib.h>
#include <time.h>
#include <sys/timeb.h>

#include<iostream>

#define NUM 10000

using T = int;
void print(T arr[], int nNum);
void swap(T *a, T *b);
long getSystemTime();
void BubbleSort(T arr[], int nNum)
{
	T i = 0, j = 0;
	for (i = 0; i < nNum; ++i)
		for (j = 1; j < nNum - i; ++j)
			if (arr[j - 1] > arr[j])
			{
				swap(&arr[j - 1], &arr[j]);
			}
}


int main()
{
	int arr[NUM] = { 0 };
	long t_start = 0, t_end = 0;

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

	for (int i = 0; i < NUM; ++i)
	{
		arr[i] = rand() % 100;
	}

	//print(arr,NUM);
	t_start = getSystemTime();
	BubbleSort(arr,NUM);
	t_end = getSystemTime();
	//print(arr, NUM);
	std::cout << "time:" << t_end - t_start << std::endl;
	return 0;
}


void swap(T *a, T *b)
{
	*a ^= *b;
	*b ^= *a;
	*a ^= *b;
}



void print(T arr[], int nNum)
{
	for (int i = 0; i < NUM; ++i)
	{
		std::cout << arr[i];
		std::cout << ",";
	}
	std::cout << "\b\n" << std::endl;
}

long getSystemTime()
{
	struct timeb tb;
	ftime(&tb);
	return tb.time * 1000 + tb.millitm;
}

快速排序

所有排序算法里命名最嚣张的一个。

最快平均最慢空间复杂度稳定性复杂性
o(N*log2N)o(N*log2N)o(n2)o(log2N)-o(N)不稳定复杂

快速排序以空间换时间，但却是效率高不稳定的排序算法。元素越多优势越明显。

划分之后一边是一个，一边是n-1个，这种极端情况的时间复杂度就是O(N^2)

最好的情况是每次都能均匀的划分序列，O(N*log2N)


void QuickSort(T arr[], int start, int end)
{
	int left = start, right = end;
	T base = arr[start];

	if (left < right)
	{
		while (left < right)
		{
			// search <base from right
			while (left < right && arr[right] >= base) --right;
			if (left < right)
			{
				arr[left] = arr[right];
				++left;
			}

			// search >base from left
			while (left < right && arr[left] < base) ++left;
			if (left < right)
			{
				arr[right] = arr[left];
				--right;
			}
		}
		arr[left] = base;

		QuickSort(arr, 0, left - 1);
		QuickSort(arr, left + 1, end);

	}

}

2. 选择排序

直接排序

最快平均最慢空间复杂度稳定性复杂性
o(n)o(n2)o(n2)o(1)不稳定简单

比冒泡快，因为交换少。

void SelectSort(T arr[], int nNum)
{
	T i = 0, j = 0;
	for (i = 0; i < nNum; ++i)
	{
		T min = i;
		for (j = 1; j < nNum - i; ++j)
		{
			if (arr[j - 1] > arr[j])
			{
				min = j;
			}

		}

		if (min != i)
		{
			swap(&arr[min], &arr[i]);
		}

	}
}

堆排序

最坏，最好，平均时间复杂度均为O(nlog2n)，不稳定且复杂。

堆是一种完全二叉树：

  • 大顶堆：arr[i] >= arr[2i + 1] && arr[i] >= arr[2i + 2]
  • 小顶堆：arr[i] <= arr[2i + 1] && arr[i] <= arr[2i + 2]

步骤：

  1. 将序列构建称为大顶堆；
  2. 取出根节点，与末尾元素交换；
  3. 对交换后的n-1个序列元素进行调整，使其满足大顶堆的性质，然后交换；

总之就是建堆和交换，不断重复。

#include <windows.h>
#include <iostream>

using namespace std;

using T = int;

void print(T arr[], int nNum)
{
	HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);
	COORD pos = { 0 };
	short x = 40, y = 0;
	int rowNum = 1;


	pos.X = x;
	pos.Y = y;
	SetConsoleCursorPosition(hOut, pos);
	printf("%2d",arr[0]);

	for (int i = 1; i < nNum; i += rowNum)
	{
		x -= 3;
		pos.X = x;
		pos.Y = ++y;
		SetConsoleCursorPosition(hOut, pos);

		rowNum *= 2;
		for (int j = 0; j < rowNum && i + j < nNum; ++j)
		{
			printf("%2d   ", arr[i + j]);
		}
	}
	system("pause");
	system("cls");
}

void HeapAdjust(T arr[], int index, int nLen)
{
	int max = index;
	int lchild = index * 2 + 1;
	int rchild = index * 2 + 2;

	if (lchild < nLen && arr[lchild] > arr[max])
	{
		max = lchild;
	}
	if (rchild < nLen && arr[rchild] > arr[max])
	{
		max = rchild;
	}

	if (max != index)
	{
		T tmp = arr[max];
		arr[max] = arr[index];
		arr[index] = tmp;

		HeapAdjust(arr,max,nLen);
	}
}

void HeapSort(T arr[], int nLen)
{
	// 1. Init big root heap
	for (int i = nLen / 2 - 1; i >= 0; --i)
	{
		HeapAdjust(arr, i, nLen);
	}

	// 2. swap
	for (int i = nLen - 1; i >= 0; --i)
	{
		T tmp = arr[0];
		arr[0] = arr[i];
		arr[i] = tmp;
		HeapAdjust(arr, 0, i);
	}
}

int main() 
{
	T arr[] = {4,2,8,0,5,7,1,3,9};
	
	print(arr, _countof(arr));
	HeapSort(arr, _countof(arr));
	print(arr, _countof(arr));

	system("pause");
	return 0;
}

3. 插入排序

直接插入

类似打扑克。。。

两种情况下效率高:

  • 序列基本有序
  • 元素少
最快平均最慢空间复杂度稳定性复杂性
o(n)o(n2)o(n2)o(1)稳定简单
void InsertSort(T arr[], int nNum)
{
	T i = 0, j = 0;
	for (i = 1; i < nNum; ++i)
	{
		if (arr[i] < arr[i - 1])
		{
			T min = arr[i];
			for (j = i- 1; 
				j >= 0 && min < arr[j];
				--j)
			{
				arr[j + 1] = arr[j];
			}
			arr[j + 1] = min;
		}

	}
}

希尔排序

最快平均最慢空间复杂度稳定性复杂性
o(n)o(n^(1.3))o(n2)o(1)不稳定复杂

实质上是一种分组插入方法，又称缩小增量排序，是插入排序的高效版本。

数列有n个元素，取一个小于n的整数gap，将待排序元素分成若干个组子序列，所有距离为gap的倍数的记录放在同一个组中；然后，对各组内的元素进行直接插入排序。 这一趟排序完成之后，每一个组的元素都是有序的。然后减小gap的值，并重复执行上述的分组和排序。重复这样的操作，当gap=1时，整个数列就是有序的。

步长递减：gap = gap / 3 + 1;

void ShellSort(T arr[], int nNum)
{
	T i = 0, j = 0, k = 0;
	int increasement = nNum;

	do
	{
		increasement = increasement / 3 + 1;
		for (i = 0; i < increasement; ++i)
		{
            
                /*
                    The same as InsertSort()
                */
			for (j = i + increasement; j < nNum; j += increasement)
			{
				if (arr[j] < arr[j - increasement])
				{
					T min = arr[j];
					for (k = j - increasement;
						k >= 0 && min < arr[k];
						k -= increasement)
					{
						arr[k + increasement] = arr[k];
					}

					arr[k + increasement] = min;
				}
			}


		}
	} while (increasement > 1);
}

4. 归并排序

3种时间复杂度均为o(nlog2n)，空间复杂度o(n)。稳定但复杂。

数量达到一定级别后，必须利用多线程，计算后合并。

void Merge(T arr[], int start, int end, int mid)
{
	int i_start = start, i_end = mid;
	int j_start = mid + 1, j_end = end;

	int nLen = 0;

	T buf[NUM] = { 0 };

	while (i_start <= i_end && j_start <= j_end)
	{
		if (arr[i_start] < arr[j_start])
		{
			buf[nLen] = arr[i_start];
			++nLen;
			++i_start;
		}
		else
		{
			buf[nLen] = arr[j_start];
			++nLen;
			++j_start;
		}
	}
	while (i_start <= i_end)
	{
		buf[nLen] = arr[i_start];
		++nLen;
		++i_start;
	}
	while (j_start <= j_end)
	{
		buf[nLen] = arr[j_start];
		++nLen;
		++j_start;
	}
	for (int i = 0; i < nLen; ++i)
	{
		arr[start + i] = buf[i];
	}
}

// interface
void MergeSort(T arr[], int start, int end)
{
	if (start == end) return;

	int mid = (start + end) / 2;

	MergeSort(arr,start,mid);
	MergeSort(arr, mid + 1, end);

	Merge(arr,start, end, mid);
}

5. 基数排序

最坏，最好，平均时间复杂度O(d(k+n))，稳定，复杂。

空间复杂度：O(n+k)

k为常数

稳定，复杂（代码还没看懂）。

算法：按位（个位、十位、百位。。。）排序，

基数排序不是比较排序，而是通过分配和收集的过程来实现排序

初始化10个桶(固定的)，桶下标为0-9
根据待排序数字的对应位的数字，把这个数字对应的item放到对应的桶中

两种排序方式：LSD和MSD，最小位优先(从右边开始)和最大位优先(从左边开始)

#include <iostream>

int maxbit(int arr[], int nLen)
{
	int max = 1; //保存最大的位数
	int p = 10;
	for (int i = 0; i < nLen; ++i)
	{
		while (arr[i] >= p)
		{
			p *= 10;
			++max;
		}
	}
	return max;
}
void RadixSort(int arr[], int nLen) //基数排序
{
	int d = maxbit(arr, nLen);
	int *tmp = new int[nLen];
	int count[10]; //计数器
	int i, j, k;
	int radix = 1;

	for (i = 0; i < d; ++i) //进行d次排序
	{
		
		memset(count, 0, 10 * sizeof(int));

		for (j = 0; j < nLen; ++j)
		{
			k = (arr[j] / radix) % 10; //统计每个桶中的记录数
			count[k]++;
		}

		for (j = 1; j < 10; ++j)
			count[j] += count[j - 1]; //将tmp中的位置依次分配给每个桶

		for (j = nLen - 1; j >= 0; --j) //将所有桶中记录依次收集到tmp中
		{
			k = (arr[j] / radix) % 10;
			tmp[ count[k] - 1 ] = arr[j];
			--count[k];
		}
		for (j = 0; j < nLen; ++j) //将临时数组的内容复制到arr中
			arr[j] = tmp[j];
		radix = radix * 10;
	}
	delete[] tmp;
}

int main()
{
	int arr[10] = {9,51,50,10,54,16,78,51,23};
	RadixSort(arr,10);
	for (int i = 0; i < 10; ++i)
	{
		printf("%d ",arr[i]);
	}
	return 0;
}
CodeStarr
关注
专栏目录
c语言大小排序算法,七种常见的数组排序算法整理(C语言版本)
weixin_39840635的博客
05-19 3327
～～～C语言版本～～～冒泡排序选择排序直接插入排序二分插入排序希尔排序快速排序堆排序#define EXCHANGE(num1, num2) { num1 = num1 ^ num2;\num2 = num1 ^ num2;\num1 = num1 ^ num2;}排序算法是否稳定:相同元素的相对在排序前后是否会发生改变，如果会，就是不稳定的，否则就是稳定的。一.冒泡排序冒泡排序原理很容易理解，...
java实现8大排序算法
04-26
本资源“java实现8大排序算法”涵盖了常见的排序方法，对于理解这些算法的工作原理以及在实际编程中应用它们非常有帮助。 1. **冒泡排序（Bubble Sort）**：冒泡排序是最简单的排序算法之一，通过不断交换相邻的...
排序整理
andor5的博客
12-07 104
内部排序 待排序记录存放在随机存储器中 外部排序 待排序记录数量大，不能一次进入内存，需对外存进行访问 插入排序 – – – – 直接 折半 2-路 表 希尔 描述 – – – – 缩小增量 – – – – – – – 减少比较 减少移动 – – 快速排序 选择排序 – – 归并排序 基数排序 – – 简单 树形 堆 – 多关键字 链式 存...
排序的整理
amara
07-19 187
排序的相关概念： 什么是排序，排序的稳定性，内部排序与外部排序 ？ 排序：就是使一串记录，照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。 稳定性：假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的相对次序保持不变，即在原序列中，r[i]=r[j]，且r[i]在r[j]之前，而在排序后的序列中，r[i]仍在r[j]之前，则称这种排序算法是稳定的；否则称为不...
数据结构-排序整理
Schwertlilien的小屋
12-28 923
排序 内排序：在排序的整个过程中，待排序的所有记录都被放置在内存之中。 外排序：由于排序的记录个数太多，不能同时放置在内存之中，整个排序过程中需要在内外存之间多次交换数据才能进行。 在数据结构中，我们主要涉及的是内排序。而根据排序过程中借助的主要操作，我们把内部排序分为：插入排序、交换排序、选择排序、归并排序。 二、简单排序 下列是三种最基础、最简单的排序方法。建议掌握（我觉得应该都会最基础的冒泡，其他的就难说捏） 提前申明，特别熟悉的我就没写注释了。如果看到我自己加了贼多的
常见排序整理
zr459927180的博客
04-26 517
原文地址：http://blog.csdn.net/xiazdong/article/details/8462393 http://blog.csdn.net/whuslei/article/details/6442755 本文是 http://blog.csdn.net/xiazdong/article/details/7304239 的补充，当年看了《大话数据结构》总结的，
八大排序 整理
weixin_43795318的博客
07-25 288
八大排序整理与比较 （参考大佬链接 https://blog.csdn.net/c406495762/article/details/78979946） 1.选择排序 每趟从待排序的记录中选出关键字最小的记录，顺序放在已排序的记录序列末尾，直到全部排序结束为止。 （1）简单选择排序 #include <iostream> #include...
排序算法大总结
guojiaqi_的博客
04-30 2189
排序算法（sorting algorithm）是用于对一组数据按照特定顺序进行排列。排序算法有着广泛的应用，因为有序数据通常能够被更高效地查找、分析和处理。 排序算法中的数据类型可以是整数、浮点数、字符或字符串等。排序的判断规则可根据需求设定，如数字大小、字符 ASCII 码顺序或自定义规则。
排序算法整理.zip
07-07
"排序算法整理.zip"这个压缩包文件显然包含了关于十种常见排序算法的详细资料，这些算法包括冒泡排序、选择排序、插入排序、计数排序、基数排序、堆排序、归并排序、快速排序、桶排序以及希尔排序。下面我们将逐一...
Java必知的8大排序
10-09
直接插入排序是一种简单直观的排序算法，它的工作原理类似于我们平时整理扑克牌。首先，将数组视为已排序的序列，然后逐个将未排序的元素插入到已排序序列的正确位置。这种排序方式在元素基本有序时表现良好，但在...
8大排序java实现
09-11
直接插入排序是一种简单的排序算法，它的工作原理类似于人们玩扑克牌时整理手牌的过程。在Java实现中，通过遍历数组，将每个元素与前面已排序的部分进行比较，如果当前元素小于前一个元素，则将其向前移动，直到...
程序员必须知道的8大排序Java版源代码
01-22
8. **基数排序（Radix Sort）**：基数排序不是基于比较的排序，而是通过按照元素的每一位进行排序。它适合处理包含大量整数且位数固定的场景，时间复杂度可达到线性，即O(d*(n+k))，其中d是数字的最大位数，k是基数...
常见排序算法整理
一个喜欢诗和远方的程序媛
04-01 319
常见的内部排序算法有：`插入排序`、`希尔排序`、`选择排序`、`冒泡排序`、`归并排序`、`快速排序`、`堆排序`、`基数排序`等。原地排序原地排序算法，就是特指空间复杂度是 O(1) 的排序算法。稳定性。这个概念是说，如果待排序的序列中存在值相等的元素，经过排序之后，相等元素之间原有的先后顺序不变。接下来讨论、理解和比较这些常用的排序算法都离不开这两点。
基于JavaScript的human-resource-backend后端开发源码设计
10-05
该项目是一款以JavaScript为主语言的HR（人力资源）后端开发源码，集成了Java、CSS、Vue和HTML等多种语言，共计1035个文件。具体文件构成如下：236个Java文件、179个JavaScript文件、104个PNG图片文件、59个CSS文件、56个Vue文件、54个GIF动画文件、42个类文件、41个XML文件、36个SVG文件、35个HTML文件。该后端系统旨在构建一个高效的人力资源管理平台。
基于Java的SpringCloud脚手架及Vue前端设计源码
10-05
该项目是一款基于Java的SpringCloud微服务架构的脚手架，同时融合了Vue前端技术。项目包含131个文件，其中Java源代码文件50个，Vue组件文件19个，JavaScript和HTML/CSS相关文件共计38个，XML配置文件13个，YAML文件8个，JSON文件4个，图片文件3个，Git忽略配置文件2个，Markdown文件2个，HTML文件2个。项目结构清晰，功能完善，适用于快速开发和部署微服务应用。
长治医学院在辽宁2020-2024各专业最低录取分数及位次表.pdf
10-05
那些年，与你同分同位次的同学都去了哪里？全国各大学在辽宁2020-2024年各专业最低录取分数及录取位次数据，高考志愿必备参考数据
留守儿童爱心网站 毕业设计 源码+数据库+论文（JAVA+SpringBoot+Vue.JS）.zip
10-05
留守儿童爱心网站 毕业设计 源码+数据库+论文（JAVA+SpringBoot+Vue.JS） 启动教程：https://www.bilibili.com/video/BV11ktveuE2d
液压打孔机_三维3D设计图纸.zip
最新发布
10-05
液压打孔机_三维3D设计图纸.zip
给料自动车床_三维3D设计图纸.zip
10-05
给料自动车床_三维3D设计图纸.zip
数据结构八大排序算法详解
"排序算法总结，包括数据结构中常见的八大排序算法：直接插入排序、希尔排序、直接选择排序、堆排序、冒泡排序、快速排序、归并排序和基数排序。此外，还提及了外部排序的基本概念。" 1. 直接插入排序：这种排序...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值