排序算法汇总

最新推荐文章于 2024-09-15 23:24:00 发布
最新推荐文章于 2024-09-15 23:24:00 发布
阅读量154 收藏
点赞数 1
分类专栏： 数据结构与算法 文章标签： 排序算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhengzhongwu/article/details/80202976
版权 
#include "stdafx.h"
#include "Sort.h"
#include <iostream>
#include <iomanip>
#include <vector>
#include <algorithm>
#include <functional>
using namespace std;

//打印
void PrintArray(vector<int>& dataArray)
{
	const int datasize = dataArray.size();
	for (int i = 0; i < (int)dataArray.size(); i++)
		cout<<dataArray[i]<<" ";
	cout<<endl;
}

//冒泡排序O(n^2),稳定
//两两比较交换，倒序从大到小不断冒出
void BubbleSort(vector<int>& dataArray)
{
	const int datasize = dataArray.size();
	if (datasize <= 0)
		return;

	for (int i = 0; i < datasize-1; i++)
	{
		for (int j = 0; j < datasize-1-i; j++)
		{
			if (dataArray[j] > dataArray[j+1])
				swap(dataArray[j], dataArray[j+1]);
		}
	}
}

//插入排序O(n^2),稳定
//将待排元素插入到已排序好的序列中
void InsertSort(vector<int>& dataArray)
{
	const int datasize = dataArray.size();
	if (datasize <= 0)
		return;

	for (int i = 1; i < datasize; i++)
	{
		int temp = dataArray[i];
		int j;
		for (j = i; j-1 >= 0 && temp < dataArray[j-1]; j--)//往后移动，直到找到第一个比待排元素小的位置
		{
			dataArray[j] = dataArray[j-1];
		}
		dataArray[j] = temp;
	}
}

//希尔排序约为O(n^1.3)，最坏的时间复杂度是O(n^2)，基于增量的插入排序，不稳定
void ShellSort(vector<int>& dataArray)
{
	const int datasize = dataArray.size();
	if (datasize <= 0)
		return;

	for (int div = datasize/2; div >= 1; div /= 2)
	{
		for (int i = div; i < datasize; i += div) //插入排序，增量为div，而不是1
		{
			int temp = dataArray[i];
			int j;
			for (j = i; j-div >= 0 && temp < dataArray[j-div]; j -= div)
			{
				dataArray[j] = dataArray[j-div];
			}
			dataArray[j] = temp;
		}
	}
}

//选择排序O(n^2),不稳定
//从小到大逐个找出
void SelectSort(vector<int>& dataArray)
{
	const int datasize = dataArray.size();
	if (datasize <= 0)
		return;

	for (int i = 0; i < datasize; i++)
	{
		int minPos = i;
		for (int j = i+1; j < datasize; j++)
		{
			if (dataArray[minPos] > dataArray[j])
				minPos = j;
		}

		if (minPos != i)
			swap(dataArray[i], dataArray[minPos]);
	}
}

//归并排序O(n*logn)，稳定
void Merge(vector<int>& dataArray, vector<int>& tempArray, int start, int mid, int end)
{
	int i = start;
	int j = mid+1;
	int k = start;
	while (i <= mid && j <= end)
	{
		if (dataArray[i] > dataArray[j])
			tempArray[k++] = dataArray[j++];
		else
			tempArray[k++] = dataArray[i++];
	}

	while (i <= mid)
		tempArray[k++] = dataArray[i++];

	while (j <= end)
		tempArray[k++] = dataArray[j++];

	for (k = start; k <= end; k++)
		dataArray[k] = tempArray[k]; 
}

void MergeSort(vector<int>& dataArray, vector<int>& tempArray, int start, int end)
{
	if (dataArray.empty())
		return;

	if (start < end)
	{
		int mid = (start+end)/2;
		MergeSort(dataArray, tempArray, start, mid);
		MergeSort(dataArray, tempArray, mid+1, end);
		Merge(dataArray, tempArray, start, mid, end);
	}
}

//向下调整函数
//pos如果从0开始，左结点为2*n+1, 右结点为2*n+2
//pos如果从1开始，左结点为2*n, 右结点为2*n+1
void SiftDown(int *pArray, int nArrayCount, int pos)
{
	//从父结点开始，父结点必须比子结点都大
	int maxpos = pos;
	while (pos*2+1 < nArrayCount)//有子结点
	{
		//从父结点和两个子结点中，选取一个最大的
		if (pArray[pos] < pArray[pos*2+1])
			maxpos = pos*2+1;
		else
			maxpos = pos;

		if (pos*2+2 < nArrayCount && pArray[maxpos] < pArray[pos*2+2])
			maxpos = pos*2+2;

		if (maxpos != pos)
		{//父结点比子结点小，则交换，并且继续往下调整
			swap(pArray[pos], pArray[maxpos]);
			pos = maxpos;
		}
		else
		{//退出，父结点比子结点大
			break;
		}
	}
}

//堆排序O(nlogn)，不稳定，基于完全二叉树(叶结点只能出现在最下层或次下层，并且不允许只有右结点没有左结点)，选择排序的一种
void HeapSort(vector<int>& dataArray)
{
	const int datasize = dataArray.size();
	if (datasize <= 0)
		return;

	//建大根堆
	for (int i = datasize/2; i >= 0; i--)  //从最后一个非叶结点开始
	{
		SiftDown(&dataArray[0], datasize, i);
	}

	//排序，依次把大的挪到最后，然后调整堆
	for (int i = dataArray.size()-1; i > 0; i--)
	{
		swap(dataArray[i], dataArray[0]); 
		SiftDown(&dataArray[0], i, 0);
	}
}

void HeapSort_STL(vector<int>& dataArray)
{
	if (dataArray.empty())
		return;

	make_heap(dataArray.begin(), dataArray.end()/*, greater<int>()*/);  //建堆
	sort_heap(dataArray.begin(), dataArray.end()/*, greater<int>()*/);  //排序
}

//快速排序O(nlogn)，分治递推, 不稳定
void QSort(vector<int>& dataArray, int left, int right)
{
	if (dataArray.empty())
		return;

	if (left >= right)
		return;

	int key = dataArray[left]; //取第一位为基准线
	int i = left;
	int j = right;
	while (i != j)
	{
		//哨兵，从右往左数，找第一个比key小的数，不断逼近
		while (dataArray[j] >= key && i < j)
			j--;

		//哨兵，从左往右数，找第一个比key大的数，不断逼近
		while (dataArray[i] <= key && i < j)
			i++;

		//交换位置
		if (i < j)
			swap(dataArray[i], dataArray[j]);
	}

	//基准数归位
	swap(dataArray[i], dataArray[left]);

	//分治
	QSort(dataArray, left, i-1);
	QSort(dataArray, i+1, right);
}

//快排优化(三数取中+插入排序+聚集相等)，解决升序、降序、重复三种极坏情况
void QSort_Optimize(vector<int>& dataArray, int left, int right)
{
	if (dataArray.empty())
		return;

	if (right - left + 1 < 10)  
	{  
		InsertSort(dataArray);  
		return;  
	}  

	if (left >= right)
		return;

	//三数取中
	int mid = (left+right)/2;
	if (dataArray[mid] > dataArray[right])
		swap(dataArray[right], dataArray[mid]);
	if (dataArray[left] > dataArray[right])
		swap(dataArray[left], dataArray[right]);
	if (dataArray[mid] > dataArray[left])
		swap(dataArray[left], dataArray[mid]);

	int key = dataArray[left]; //取第一位为基准线
	int i = left;
	int j = right;
	int leftlen = 0;
	int rightlen = 0;
	while (i != j)
	{
		//哨兵，从右往左数，找第一个比base小的数，不断逼近
		while (dataArray[j] >= key && i < j)
		{
			if (dataArray[j] == key)//把相同的往后放
			{
				swap(dataArray[j],dataArray[right-rightlen]);
				rightlen++;
			}

			j--;
		}

		//哨兵，从左往右数，找第一个比base大的数，不断逼近
		while (dataArray[i] <= key && i < j)
		{
			if (dataArray[i] == key)//把相同的往前放
			{
				swap(dataArray[i],dataArray[left+leftlen]);
				leftlen++;
			}

			i++;
		}

		//交换位置
		if (i < j)
			swap(dataArray[i], dataArray[j]);
	}

	//基准数归位，下面的过程包含了这个步骤，所以不需要再进行
	//swap(dataArray[i], dataArray[left]);

	//把相同的数挪到基准数的两边
	int low = left;
	int high = i;
	while (low <= high && dataArray[low] == key)
	{
		swap(dataArray[low], dataArray[high]);
		low++;
		high--;
	}

	low = i+1;
	high = right;
	while (low <= high && dataArray[high] == key)
	{
		swap(dataArray[low], dataArray[high]);
		low++;
		high--;
	}

	//分治
	QSort_Optimize(dataArray, left, i-leftlen);
	QSort_Optimize(dataArray, i+1+rightlen, right);
}

//基数排序O(n)，稳定
void RadixSort(vector<int>& dataArray)
{
	const int datasize = dataArray.size();
	if (datasize <= 0)
		return;

	//求最大位数
	int maxbit = 1;
	int p = 10;
	for (int i = 0; i < datasize; i++)
	{
		while (dataArray[i] >= p)
		{
			p *= 10;
			maxbit++;
		}
	}

	//从低到高按位排序，从个位开始
	int countArray[10]; //10进制10个桶
	vector<int> tempArray(dataArray.size(), 0);
	for (int i = 0, radix =1; i <= maxbit; i++, radix *= 10) //按位
	{
		//统计每个桶中的记录数
		memset(countArray, 0 , sizeof(countArray));
		for (int j = 0; j < datasize; j++) 
			countArray[dataArray[j]/radix%10]++;

		//将记录数转换为位置
		for (int j = 1; j < 10; j++)
			countArray[j] = countArray[j-1]+countArray[j];

		//按位排序缓存到tempArray
		for (int j = datasize-1, index = 0; j >= 0; j--)//倒序
		{
			index = dataArray[j]/radix%10;
			tempArray[countArray[index]-1] = dataArray[j];
			countArray[index]--;
		}

		//复制
		for (int j = 0; j < datasize; j++)
			dataArray[j] = tempArray[j];
	}
}

//计数排序O(N+M)，稳定，最简单的桶排序
void CountingSort(vector<int>& dataArray)
{
	const int datasize = dataArray.size();
	if (datasize <= 0)
		return;

	//查找出最大和最小值
	int min = dataArray[0];
	int max = dataArray[0];
	for (int i = 1; i < datasize; i++)
	{
		if (dataArray[i] > max)
			max = dataArray[i];
		else if (dataArray[i] < min)
			min = dataArray[i];
	}

	//计算桶数量，并投递到不同桶
	int bucketNum = max-min+1;
	vector<int> bucket(bucketNum, 0);
	for (int i = 0; i < datasize; i++)
		bucket[dataArray[i]-min]++;

	//排序
	for (unsigned int i = 0, index = 0; i < bucket.size(); i++)
	{
		while (bucket[i] > 0)
		{
			dataArray[index++] = i+min;
			bucket[i]--;
		}
	}
}

//桶排序O(N+M)，稳定，分堆处理
void BucketSort(vector<int>& dataArray)
{
	const int datasize = dataArray.size();
	if (datasize <= 0)
		return;

	#define BUCKET(i) (i/10)// 桶排序映射函数

	//创建桶，并根据映射函数分堆
	const int bucketNum = 10;
	vector<vector<int>> buckets(bucketNum); //创建bucketNum个桶
	for (int i = 0; i < datasize; i++)
	{
		buckets[BUCKET(dataArray[i])].push_back(dataArray[i]);
	}

	//开始对每一个桶进行插入排序
	for (int i = 0; i < bucketNum; ++i)
	{
		InsertSort(buckets[i]);
	}   

	//合并
	for (int i = 0, index = 0; i < bucketNum; ++i)
	{
		for (unsigned int j = 0; j < buckets[i].size(); j++)
			dataArray[index++] = buckets[i][j];
	}
}

void SortTest()
{
	const int pArray[] = {10,6,5,4,1,3,2,7,9,8,5,6,9};
	const int nArrayCount = sizeof(pArray)/sizeof(pArray[0]);
	std::vector<int> dataArray; 

	cout<<"冒泡排序:"<<endl;
	dataArray.assign(pArray, pArray+nArrayCount);
	BubbleSort(dataArray);
	PrintArray(dataArray);

	cout<<"堆排序:"<<endl;
	dataArray.assign(pArray, pArray+nArrayCount);
	HeapSort(dataArray);
	PrintArray(dataArray);

	cout<<"堆排序(stl):"<<endl;
	dataArray.assign(pArray, pArray+nArrayCount);
	HeapSort_STL(dataArray);
	PrintArray(dataArray);
	
	cout<<"快速排序:"<<endl;
	dataArray.assign(pArray, pArray+nArrayCount);
	QSort(dataArray, 0, dataArray.size()-1);
	PrintArray(dataArray);

	cout<<"快速排序优化(三数取中+插入排序+聚集相等):"<<endl;
	dataArray.assign(pArray, pArray+nArrayCount);
	QSort_Optimize(dataArray, 0, dataArray.size()-1);
	PrintArray(dataArray);

	cout<<"插入排序:"<<endl;
	dataArray.assign(pArray, pArray+nArrayCount);
	InsertSort(dataArray);
	PrintArray(dataArray);

	cout<<"希尔排序:"<<endl;
	dataArray.assign(pArray, pArray+nArrayCount);
	ShellSort(dataArray);
	PrintArray(dataArray);

	cout<<"选择排序:"<<endl;
	dataArray.assign(pArray, pArray+nArrayCount);
	SelectSort(dataArray);
	PrintArray(dataArray);

	cout<<"归并排序:"<<endl;
	dataArray.assign(pArray, pArray+nArrayCount);
	vector<int> tempArray(dataArray.size(), 0);
	MergeSort(dataArray, tempArray, 0, dataArray.size()-1);
	PrintArray(dataArray);

	cout<<"基数排序:"<<endl;
	dataArray.assign(pArray, pArray+nArrayCount);
	RadixSort(dataArray);
	PrintArray(dataArray);

	cout<<"桶排序:"<<endl;
	dataArray.assign(pArray, pArray+nArrayCount);
	BucketSort(dataArray);
	PrintArray(dataArray);

	cout<<"计数排序:"<<endl;
	dataArray.assign(pArray, pArray+nArrayCount);
	CountingSort(dataArray);
	PrintArray(dataArray);
}

zhengzhongwu_2006
关注
专栏目录
排序算法
萌萌哒博客
02-24 325
有好多种排序方法 选择排序 快速排序 冒泡排序 插入排序 等等 选择排序基本思想： 假设排序表为L[1…n],第i趟排序从表中选择关键字最小的元素与Li交换，第一趟排序可以确定一个元素的最终位置，这样经过n-1趟排序就可以使得整个排序表有序。 代码：- void SelectSort(ElemType arr[], int length) { int i, j, min;
常见排序算法汇总
夜槿笙歌的博客
04-17 8472
整理一下之前学习的各种排序算法
常见的排序算法汇总（详解篇）
m0_73634434的博客
08-19 1321
所谓排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。稳定性 ：假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的相对次序保持不变，即在原序列中， r[i]=r[j] ，且 r[i] 在 r[j] 之前，而在排序后的序列中， r[i] 仍在 r[j] 之前，则称这种排序算法是稳定的；否则称为不稳定的。数据元素全部放在内存中的排序。数据元素太多不能同时放在内存中，根据排序过程的要求不能在内外存之间移动数据的排序。
python常用排序算法汇总
02-19
该程序包含7大排序算法: # sort.bubbleSort() #冒泡排序 # sort.shellSort() #希尔排序 # sort.insertionSort() #插入排序 # sort.Selectionsort1() #选择排序 # sort.heapSort() #堆排序 # sort.countSort() ...
Java排序算法汇总大全.doc
09-01
Java排序算法汇总大全 在计算机科学中，排序算法是用于对数据序列进行排列的算法，以便根据特定标准对其进行组织。本文将详细介绍Java中常见的几种排序算法，并提供它们的基本原理、性能分析以及适用场景。 1. ...
排序算法汇总.pdf
11-23
### 排序算法汇总 #### 一、基本概念与分类 **1. 什么是排序** 排序是一种基础且重要的数据处理技术，它涉及到对一组数据按照特定的规则进行组织，通常是根据记录中的某个或某些关键字段来进行升序或降序排列。...
排序算法_排序算法汇总_排序算法_gettingzop_
09-29
在计算机科学领域，排序算法是数据处理中至关重要的一部分，它涉及到如何有效地对一系列元素进行排列。本知识库主要涵盖了多种经典的排序算法，旨在为学习者提供一个全面的概述和理解。下面将逐一介绍这些排序算法...
Python常见排序算法汇总共2页.pdf.zip
10-28
这个名为"Python常见排序算法汇总共2页.pdf.zip"的压缩包文件，很可能是包含了一份关于Python中常用排序算法的总结文档，虽然描述中并未提供详细内容，但我们可以推测它可能涵盖了以下常见的Python排序算法： ...
「数组」十大排序：精讲与分析（C++）
dakingffo的博客
09-15 249
截止目前，我们已经讲解并分析了十种最常见的排序算法，附对应文章链接和全体Code。
【数据结构与算法】排序算法之快速排序（简）
小雨的分享斋
09-15 199
简洁版快速排序，适用于有基础的开发人员回想
【初阶数据结构】排序
最新发布
2401_82610555的博客
09-15 322
1. 元素集合越接近有序，直接插入排序算法的时间效率越高。O(N^2)。O(1)1. 希尔排序是对直接插入排序的优化。2. 当gap > 1时都是预排序，目的是让数组更接近于有序。当gap == 1时，数组已经接近有序的了，这样就 会很快。这样整体而言，可以达到优化的效果。我们实现后可以进行性能测试的对比。3. 希尔排序的时间复杂度不好计算，因为gap的取值方法很多，导致很难去计算，因此在好些书中给出的希尔排序的时间复杂度都不固定。1. 冒泡排序是一种非常容易理解的排序。O(N^2)O(1)
【数据结构】排序算法系列——堆排序（附源码+图解）
Skrrapper的博客
09-14 399
但是当我们根据[[二叉树]]的遍历来进行输出时，会发现同一个父节点的子节点之间以及其中一个子节点的子节点实际上是无序的，例如60和10，它们之间是大于的关系；），然后重新构造堆，那么此时的第二个根节点就仅次于第一个根节点的大小，这么以此类推，最终将所有节点根据大、次大、第三大的顺序排序在数组中，那么也就成功构建出了有序的数组。根据堆的有序性和完全二叉树的性质，我们得知将其用在排序上是可行的，并且还能够有效减少重复比较的次数，这何乐而不为呢？可惜的是，这样的操作并没有把每一趟的比较结果保存下来，
归并排序（Merge Sort）
Broken_x的博客
09-15 550
归并排序（Merge Sort）是一种经典的排序算法，它采用分治法（Divide and Conquer）策略，将一个大数组分为两个小数组，分别进行排序，然后将这两个已排序的小数组合并成一个有序的大数组。归并排序在最坏情况下的时间复杂度为 O(nlog⁡n)O(nlogn)，并且是一种稳定的排序算法。归并排序是一种高效且稳定的排序算法，适用于大规模数据的排序。通过分治法的思想，归并排序能够在最坏情况下保持 O(nlog⁡n)O(nlogn) 的时间复杂度。
5020-微信小程序基于JAVA微信点餐小程序设计+ssm（源码+数据库+lun文）.zip
09-15
本系统主要针对计算机相关专业的正在做毕业设计的学生和需要项目实战练习的学习者，可作为毕业设计、课程设计、期末大作业。本系统主要针对计算机相关专业的正在做毕业设计的学生和需要项目实战练习的学习者，可作为毕业设计、课程设计、期末大作业。本系统主要针对计算机相关专业的正在做毕业设计的学生和需要项目实战练习的学习者，可作为毕业设计、课程设计、期末大作业。本系统主要针对计算机相关专业的正在做毕业设计的学生和需要项目实战练习的学习者，可作为毕业设计、课程设计、期末大作业。
基于 Flask 的数字猜谜系统.zip
09-15
该项目是一个基于 Flask 框架的数字猜谜游戏。通过 Flask 搭建了一个 Web 应用，用户可以通过界面参与数字猜谜游戏。项目简单易懂，适合初学者了解 Flask 框架的基本使用以及 Web 开发的基础知识。同时，该项目也有一定的娱乐性质，可以提供给用户休闲娱乐的时光。 1、资源项目源码均已通过严格测试验证，保证能够正常运行； 2、项目问题、技术讨论，可以给博主私信或留言，博主看到后会第一时间与您进行沟通； 3、本项目比较适合计算机领域相关的毕业设计课题、课程作业等使用，尤其对于人工智能、计算机科学与技术等相关专业，更为适合； 4、下载使用后，可先查看ReaDME.md文件（如有），本项目仅用作交流学习参考，请切勿用于商业用途。
5206-微信小程序投票评选系统的设计与实现ssm（源码+数据库+lun文）.zip
09-15
本系统主要针对计算机相关专业的正在做毕业设计的学生和需要项目实战练习的学习者，可作为毕业设计、课程设计、期末大作业。本系统主要针对计算机相关专业的正在做毕业设计的学生和需要项目实战练习的学习者，可作为毕业设计、课程设计、期末大作业。本系统主要针对计算机相关专业的正在做毕业设计的学生和需要项目实战练习的学习者，可作为毕业设计、课程设计、期末大作业。本系统主要针对计算机相关专业的正在做毕业设计的学生和需要项目实战练习的学习者，可作为毕业设计、课程设计、期末大作业。本系统主要针对计算机相关专业的正在做毕业设计的学生和需要项目实战练习的学习者，可作为毕业设计、课程设计、期末大作业。本系统主要针对计算机相关专业的正在做毕业设计的学生和需要项目实战练习的学习者，可作为毕业设计、课程设计、期末大作业。
PeaZip 64 bit 9.9.1 free 解压缩工具 杜绝360垃圾
09-15
PeaZip 64 bit 9.9.1 free 解压缩工具 杜绝360垃圾
JAVA排序算法详解与实现
"这篇文档是关于JAVA排序算法的汇总，涵盖了多种常见的排序算法，并提供了相关的JAVA实现。排序算法包括插入排序、交换排序、选择排序、归并排序和基数排序。文档还提到了根据数据规模和初始顺序选择合适排序算法的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值