C++七大排序算法

最新推荐文章于 2024-06-06 09:34:24 发布
最新推荐文章于 2024-06-06 09:34:24 发布
阅读量136 收藏
点赞数
文章标签： c++ 算法 排序算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/VSphere_/article/details/126038004
版权

选择排序

  • 排序思想：

  1. 在数组中找到最大值，记录下标maxindex，与数组中最后一个数进行交换 swap(a[maxindex],a[n-1]);

  2. 在剩下的数组元素中，重新找到最大值，并重复第一次操作 swap(a[maxindex],a[n-2]),直到数组排序完毕。

  • 时间复杂度

最优最差都是要遍历数组n*n次，所以时间复杂度为O(n2)

选择排序是不稳定算法：举个栗子，5 8 5 2 9，第一遍之后，2会与5交换，那么原序列中两个5的顺序就被破坏了。所以不是稳定的排序算法。

  • 代码实现

#include<iostream>
using namespace std;


void selectSort(int a[], int n) {
	for (int j = n; j > 1; j--) {
		int max = a[0];
		int maxindex = 0;
		for (int i = 1; i < j; i++) {
			if (a[i] > max) {
				max = a[i];
				maxindex = i;
			}
		}
		swap(a[maxindex], a[j - 1]);
	}
}
void print(int a[], int n) {
	for (int i = 0; i < n; i++) {
		cout << a[i] << " ";
	}
	cout << endl;
}


int main() {
	int a[] = { 9,7,5,3,2,1 };
	selectSort(a, 6);
	print(a, 6);
	return 0;
}

冒泡排序

  • 排序思想

  1. 从左到右，比较相邻的元素。如果第一个比第二个大，就交换他们两个，将最大的数放在数组的最后（也就是下标n-1位置）

  2. 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。

  3. 针对所有的元素重复以上的步骤，除了最后一个。

  4. 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

  • 时间复杂度

最快：当输入的数据已经是正序时（都已经是正序了，我还要你冒泡排序有何用啊）。所以时 间复杂度是O(n);

最慢：当输入的数据是反序时（写一个 for 循环反序输出数据不就行了，干嘛要用你冒泡排序 呢，我是闲的吗）。所以时间复杂度是O(n2)

稳定；

  • 代码实现

优化：当数组在整个排序遍历过程中，没有发生交换，说明排序数组已经是有序的了，此时可以直接结束排序过程。

#include <iostream>
using namespace std;
void bubbleSort(int a[], int n) {
	for (int j = n; j > 0; j--) {
		bool flag = true;
		for (int i = 0; i < j-1; i++) {
			if (a[i] > a[i + 1]) {
				flag = false;
				swap(a[i], a[i + 1]);
			}
		}
		if (flag == true) {
			return;
		}
	}
}
void print(int a[], int n) {
	for (int i = 0; i < n; i++) {
		cout << a[i] << " ";
	}
	cout << endl;
}


int main() {
	int a[] = { 2,3,5,7,0,4 };
	bubbleSort(a, 6);
	print(a, 6);
	return 0;
}

插入排序

  • 排序思想

  1. 将第一待排序序列第一个元素看做一个有序序列，把第二个元素到最后一个元素当成是未排序序列。

  2. 从头到尾依次扫描未排序序列，将扫描到的每个元素插入有序序列的适当位置。（如果待插入的元素与有序序列中的某个元素相等，则将待插入元素插入到相等元素的后面。）

  • 时间复杂度

  • 代码实现

优化算法，叫做拆半插入。

#include<iostream>
using namespace std;


void insertSort(int a[], int n) {
	//j代表无序表第一个元素下标
	for (int j = 1; j < n; j++) {
		//i代表有序表最后一个元素下标
		int i = j - 1;
		while (i >= 0 && a[i+1] < a[i]) {
			swap(a[i + 1], a[i]);
			i--;
		}
	}
}
void print(int a[],int n) {
	for (int i = 0; i < n; i++) {
		cout << a[i] << " ";
	}
	cout << endl;
}
int main() {
	int a[] = { 2,4,6,8,0,3 };
	insertSort(a, 6);
	print(a, 6);
	return 0;
}

桶排序

  • 排序思想

  1. 遍历原数组，找到最大值max，申请max+1个桶，初始值设为0，，即vector<int> bucket(max+1,0);

  2. 遍历原数组，找到每个数值对应的桶号，并对桶计数++，即bucket[a[i]]++;

  3. 遍历桶数组，看对应的桶内计数为多少，就取出多少下标值，放到原数组，即while(bucket[i]--) a[index++] = i;

  • 时间复杂度

最快：当输入的数据可以均匀的分配到每一个桶中。

最慢：当输入的数据被分配到了同一个桶中。

  • 代码实现

#include<iostream>
#include<string>
#include<vector>
using namespace std;


void bucket(vector<int>&vec) {
	if (vec.size() == 0) {
		return;
	}
	int max = vec[0];
	for (int i = 1; i < vec.size(); i++) {
		if (max < vec[i]) {
			max = vec[i];
		}
	}
	//申请max+1个桶
	vector<int> bucket(max + 1, 0);
	//遍历原数组，把相应的球放到对应的桶里
	for (int i = 0; i < vec.size(); i++) {
		bucket[vec[i]]++;
	}
	int index = 0;
	//把桶中的球取出来，i代表数值，bucket[i]代表的是个数
	for (int i = 0; i < bucket.size(); i++) {
		while (bucket[i]>0) {
			vec[index++] = i;
			bucket[i]--;
		}
	}
}
void print(vector<int>& vec) {
	for (int i = 0; i < vec.size(); i++) {
		cout << vec[i] << " ";
	}
	cout << endl;
}
int main() {
	vector<int> vec = { 2,4,6,1,3,5 };
	bucket(vec);
	print(vec);
	return 0;
}

堆排序

  • 排序思想

  1. 将待排序数组形象成一个堆结构，并将其调整为最大堆结构（左孩子2*i+1，右孩子2*i+2；最大堆结构中任何父节点的值都大于其子节点的值）

  2. 将堆顶元素与待排序数组最后一个元素交换，swap(a[0],a[nums-1]);

  3. 待排序的数据量减少一个，即nums--；将待排序数组重新调整最大堆结构，重复第二步，循环n-1次，将所有数据排序完毕

  • 时间复杂度

堆排序是一种选择排序，整体主要由构建初始堆+交换堆顶元素和末尾元素并重建堆两部分组成。其中构建初始堆经推导复杂度为O(n)，在交换并重建堆的过程中，需交换n-1次，而重建堆的过程中，根据完全二叉树的性质，[log2(n-1),log2(n-2)...1]逐步递减，近似为nlogn。所以堆排序时间复杂度最好和最坏情况下都是O(nlogn)级。

  • 代码实现

#include<iostream>
#include<vector>
using namespace std;


void adjust(vector<int>&vec, int start, int end) {
	int dad = start;
	int son = 2 * dad + 1;
	while (son <= end) {
		if (son + 1 < end&&vec[son] < vec[son + 1]) {
			son++;
		}
		if (vec[son] > vec[dad]) {
			swap(vec[son], vec[dad]);
		}
		dad = son;
		son = 2 * dad + 1;
	}
}
void head_sort(vector<int>&vec) {
	int n = vec.size();
	for (int i = n / 2 - 1; i >= 0; i--) {
		adjust(vec, i, n - 1);
	}
	for (int i = n - 1; i >= 0; i--) {
		swap(vec[0], vec[i]);
		adjust(vec, 0, i - 1);
	}
}


int main() {
	vector<int> vec = { 3,5,7,9,4,1 };
	head_sort(vec);
	for (int i = 0; i < vec.size(); i++) {
		cout << vec[i] << " ";
	}
	cout << endl;
	return 0;
}

快速排序

  • 排序思想

  • 三色旗思想：

一个数组只有0，1，2三种元素构成，请使用交换，原地排序而不是使用技术进行排序。

  1. 定义两个变量，i和j(下标)；

i:<=i的部分都是比1小的，i的初值 == -1；

j：>=j的部分都是比1大的，j的初值 == n；

  1. 从index = 0开始遍历

如果a[index]==0,swap(a[index++],a[++i]);

(这里index++的原因是，index左边不可能有==2的数据了)

如果a[index]==1,index++;

如果a[index]==1,swap(a[index],a[--j]);

#include <iostream>
#include<vector>
using namespace std;


void Quick(vector<int>&vec, int L, int R) {
	int i = L - 1;
	int j = R + 1;
	int temp = 1;
	int index = 0;
	while (index < j) {
		if (vec[index] == temp) {
			index++;
		}
		else if (vec[index] < temp) {
			swap(vec[index++], vec[++i]);
		}
		else {
			swap(vec[index], vec[--j]);
		}
	}
	
}


int main() {
	vector<int> vec = { 2,1,1,0,0,2 };
	Quick(vec,0, vec.size()-1);
	for (auto it : vec) {
		cout << it << " ";
	}
	return 0;
}

  • 快排思想：

第一步三色旗思想：找一个基准值（这里选择排序数组最左边的那个值），然后将排序数组分成三部分

第一部分：数据全都小于基准值

第二部分：数据全都等于基准值

第三部分：数据全都大于基准值

第二步：

将第一部分和第三部分分别进行三色旗问题，直到 i >= j.

#include <iostream>
#include<vector>
using namespace std;


pair<int,int> Quick(vector<int>&vec, int L, int R) {
	int i = L - 1;
	int j = R + 1;
	int temp = vec[L];
	int index = L;
	while (index < j) {
		if (vec[index] == temp) {
			index++;
		}
		else if (vec[index] < temp) {
			swap(vec[index++], vec[++i]);
		}
		else {
			swap(vec[index], vec[--j]);
		}
	}
	return make_pair(i, j);
}


void Quick_sort(vector<int>&vec, int L, int R) {
	if (L >= R) return;
	pair<int,int> p = Quick(vec, L, R);
	Quick_sort(vec, L, p.first);
	Quick_sort(vec, p.second, R);
}
int main() {
	vector<int> vec = { 2,4,1,9,0,6 };
	Quick_sort(vec,0, vec.size()-1);
	for (auto it : vec) {
		cout << it << " ";
		
	}
	return 0;
}

  • 时间复杂度

归并排序

  • 排序思想

  1. 申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列；

  2. 设定两个指针，最初位置分别为两个已经排序序列的起始位置；

  3. 比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置；

  4. 重复步骤 3 直到某一指针达到序列尾；

  5. 将另一序列剩下的所有元素直接复制到合并序列尾。

  • 时间复杂度

  • 代码实现

#include <iostream>
#include<vector>
using namespace std;


void Merg(vector<int>&vec, int L, int mid, int R) {
	//先申请一个辅助数组大小为：R-L+1；
	vector<int> temp(R - L + 1);
	int i = L, j = mid + 1, index = 0;
	//利用while循环比较两个有序数组，分别为：L到mid，mid+1到R
	while (i <= mid && j <= R) {
		if (vec[i] < vec[j]) {
			temp[index++] = vec[i++];
		}
		else {
			temp[index++] = vec[j++];
		}
	}
	while (i <= mid) {
		temp[index++] = vec[i++];
	}
	while (j <= R) {
		temp[index++] = vec[j++];
	}
	index = L;
	for (int i = 0; i < (R - L + 1); i++) {
		vec[index++] = temp[i];
	}
}
void merg_sort(vector<int>&vec, int L, int R) {
	if (L >= R) return;
	int mid = (R - L) / 2 + L;
	merg_sort(vec, L, mid);
	merg_sort(vec, mid + 1, R);
	Merg(vec, L, mid, R);
}
int main() {
	vector<int>vec = { 20,90,60,70,40,30,50 };
	merg_sort(vec, 0, vec.size() - 1);
	for (auto it : vec) {
		cout << it << " ";
	}
	return 0;
}

VSphere_
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
七大排序算法c++实现
10-03
七大排序算法C++实现，包括冒泡排序、选择排序、插入排序、希尔排序、快速排序、归并排序、堆排序。代码随机生成数组来排序，MAX1定义了数组个数，用QueryPerformanceCounterday打印除了各算法用时。
c++之七种经典排序算法
02-23
本文主要探讨了七种经典的排序算法在C++中的实现、理论讲解以及复杂度分析，包括冒泡排序、选择排序、插入排序、希尔排序、堆排序、快速排序和归并排序。 1. 冒泡排序： 冒泡排序是一种简单的排序方法，通过相邻...
C++排序算法
Ru_Ella的博客
03-31 2488
1.冒泡排序 冒牌排序是一种经典的排序算法，它是一种稳定的排序。其原理是如果前面的数比后面的数要大，就交换两个数字的位置。代码如下： for(int i=1; i<=n-1; i++){ for(int j=1; j<=n; j++){ if(a[j]>a[j+1]){ swap(a[j],a[j+1]); } } } 2.归并排序 归并排序的思想是把一串数字从中间分开，然后两边分别排序，最后再合并，从而得到
C++-排序算法详解
最新发布
一然明月(嵌入式)的博客
06-06 1979
排序算法是一种将一组数据按照特定顺序（如升序或降序）进行排列的算法。其主要目的是对一组无序的数据进行整理，使得它们呈现出一定的有序性。主要排序算法有:冒泡排序.插入排序,快速排序.选择排序,归并排序,堆排序.
排序算法小结
11-18 1872
排序小结    排序算法是一种基本并且常用的算法。由于实际工作中处理的数量巨大，所以排序算法对算法本身的速度要求很高。    而一般我们所谓的算法的性能主要是指算法的复杂度，一般用O方法来表示。在后面我将给出详细的说明。    对于排序的算法我想先做一点简单的介绍，也是给这篇文章理一个提纲。    我将按照算法的复杂度，从简单到难来分析算法。    第一部分是简单排序算法，后面你将看到他们的共
七大基本排序算法C/C++（已优化及测试）
weixin_34389926的博客
03-25 97
七大基本排序算法 已通过VS2015环境测试 可能不是最优算法，但是比基本版更好 完整项目GitHub 地址：https://github.com/cugwyman/7-Sorts BubbleSort冒泡排序 //BubbleSort冒泡排序，复杂度O(n^2) //@param flag 优化算法 voi...
算法系列15天速成——第一天 七大经典排序【上】
weixin_33698043的博客
11-14 202
今天是开篇，得要吹一下算法，算法就好比程序开发中的利剑，所到之处，刀起头落。   针对现实中的排序问题，算法有七把利剑可以助你马道成功。   首先排序分为四种：        交换排序： 包括冒泡排序，快速排序。       选择排序： 包括直接选择排序，堆排序。       插入排序： 包括直接插入排序，希尔排序。       合并排序： 合并排序。   那么今天我们讲的就是...
七大排序算法
03-14
包含（归并排序、堆排序、希尔排序、快速排序、冒泡排序、直接插入/选择排序）七种排序算法的C++代码实现
七大查找算法及C++源码.pdf
09-13
本文将详细探讨七大查找算法，其中包括顺序查找和二分查找，这两种查找算法在实际应用中非常常见。 1. **顺序查找**： 顺序查找是最基础的查找算法，适用于任何存储结构的线性表，无论是顺序存储还是链式存储。它...
经典7大排序算法详解
01-16
### 经典七大排序算法详解 #### 一、冒泡排序 冒泡排序是一种简单的排序算法，通过重复地遍历列表，比较每对相邻元素，若顺序错误则交换它们。遍历列表的工作会重复进行直到没有更多的交换需要，也就是说列表已经...
C++实现七大排序算法
Coast_Tt的博客
03-10 1888
七大排序方法比较： 排序方法 平均情况 最好情况 最坏情况 辅助空间 稳定性 冒泡排序 O(N2) O(N) O(N2) O(1) 稳定 选择排序 O(N2) O(N2) O(N2) O(1) 不稳定 插入排序 O(N2) O(N) O(N2) O(1) 稳定 希尔排序 O(NlogN)-O(N2) O(N1.3) O(N2) O(1) 不稳
c++排序算法
11-24
此排序算法为本人平常学习练习所写，在学习的过程中也是非常希望和大家分享交流
C++中七大排序算法
繁华落尽梦一场
12-18 1051
这里的七大指的是快速排序、堆排序、归并排序、希尔排序、选择排序、插入排序和冒泡排序，由于桶排序应用场景有限，这里就不写了。先对比一下这几种排序的效率： 观察表发现一个有趣的现象：对于堆排序和归并排序，他们的最好、最坏和平均的时间复杂度都是O(nlogn)，也就是说数据的初始化顺序对这两种算法是没有影响的。先来一个直观的比较（500000条数据） 直观来看，快速排序、堆排序和归并排序的时...
七大排序算法（c++）https://leetcode.cn/circle/discuss/eBo9UB/
我的博客
03-26 204
排序算法总结： 1、排序的稳定性：对于两个相等的元素，排序后的顺序和排序前一致，该算法是稳定的，反之亦然 2、内排序和外排序：内排序：排序过程中，所有数据都在内存中；数据量大的，需要内外存之间多次交换数据的就是外排序 内排序的性能：时间性能，辅助空间，算法复杂度 #define MAXSIZE 10 typedef struct { int r[MAXSIZE + 1]; // r[0]存...
十大排序算法（C++实现）
热门推荐
yj_coder的博客
05-15 2万+
本文参照AcWing闫学灿大神的讲解，整理了一下排序算法的实现。 算法总结 排序算法 平均时间复杂度 最好情况 最坏情况 空间复杂度 稳定性 冒泡排序 O(n²) O(n) O(n²) O(1) 稳定 选择排序 O(n²) O(n²) O(n²) O(1) 不稳定 插入排序 ...
[C++]七大经典排序算法详解（代码实现+解析）
cpb____的博客
03-17 5328
各种排序算法动图解析请参考 各种排序算法复杂度对比 冒泡排序法 冒泡排序是所有排序算法中相对简单且容易理解的算法，它的核心思想：通过for循环不断遍历需要排序的元素，依次比较相邻的两个元素，若不满足指定的顺序（可以从大到小排序，也可以反过来），就交换两个元素，直至完成排序。 1.比较相邻的元素。如果第一个比第二个大，就交换它们两个； 2.对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数； 3.针对所有的元素重复以上的步骤，除了最后一个； 4.重复步骤1~3，直
C++ 排序算法
AI蜗牛之家
07-22 1322
经典排序算法总结（代码） ·冒泡法 ·快速排序 ·插入排序 ·希尔（shell）排序 ·选择排序 ·堆排序 ·归并排序   附： 排序算法原理：http://zh.wikipedia.org/wiki/Category:%E6%8E%92%E5%BA%8F%E7%AE%97%E6%B3%95 flash演示: http://www.tyut.edu.cn/keche
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值