c++实现各种排序

最新推荐文章于 2024-07-19 13:40:17 发布
最新推荐文章于 2024-07-19 13:40:17 发布
阅读量575 收藏 2
点赞数
CC 4.0 BY-SA版权
分类专栏： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/jurui3973/article/details/80951520
本文详细介绍了使用C++实现的七大经典排序算法，包括归并排序、冒泡排序、Shell排序、选择排序、插入排序、堆排序和快速排序，涵盖了不同类型的排序思想和方法。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

 一、归并排序

#define _CRT_SECURE_NO_WARNINGS



#include<iostream>
#include<string>
#include<vector>
#include<set>
#include <cstdlib>
#include <cstddef>
#include <list>
#include <functional>
#include <unordered_map>
#include "tes2.h"
#include <algorithm>
#include <iterator>
#include <ostream>



using std::cin;
using std::cout;
using std::endl;
using std::string;
using std::vector;
using std::list;
using std::unordered_map;



void Msort(int *mat, int *temp, int left, int right);
void Merge(int *mat, int *temp, int left, int middle, int right);
void mergeSort(int *mat,int n)
{
	if (n ==  1) 
		return;
	int *temp = new int[n];
	Msort(mat, temp, 0, n - 1);

	delete[]temp;
	

}

void Msort(int *mat, int *temp, int left, int right)
{
	if (left < right)
	{
		int middle = (left + right) / 2;
		Msort(mat, temp, left, middle);
		Msort(mat, temp, middle+1, right);
		Merge(mat, temp, left, middle, right);
	}
}

void Merge(int *mat, int *temp, int left, int middle, int right)
{
	int first = left;
	int result = left;
	int endfirst = middle;
	int endsecond = right;
	middle++;
	while (left <= endfirst && middle <= endsecond)
	{
		if (mat[left] <= mat[middle])
			temp[result++] = mat[left++];
		else
			temp[result++] = mat[middle++];
	}
	while(left<=endfirst)
		temp[result++] = mat[left++];
	while (middle <= endsecond)
		temp[result++] = mat[middle++];

	for (int i = first; i < result; i++)
		mat[i] = temp[i];
}

int main()
{
	int a[] = {8,2,5,3,6,9,1,4,7};
	
	mergeSort(a, 9);
	for (auto v : a)
		cout << v << " ";
	cout << endl;
	
	
	
	system("pause");
	return 0;
}

二、冒泡排序

#define _CRT_SECURE_NO_WARNINGS



#include<iostream>
#include<string>
#include<vector>
#include<fstream>
#include<list>



using std::cin;
using std::cout;
using std::endl;
using std::ifstream;
using std::ofstream;
using std::string;
using std::vector;
using std::pair;
using std::list;

void Bubblesort(int *a, int len)
{
	bool F = false;
	int temp;
	for (int i = 0; i < len-1; i++)
	{
		F = false;
		for (int j = 0; j < len - i-1; j++)
		{
			if (a[j] > a[j + 1])
			{
				temp = a[j + 1];
				a[j + 1] = a[j];
				a[j] = temp;
				F = true;
			}
			
		}
		if (F == false)
			break;
	}
}

int main(int argc, char * argv[])
{
	

	int a[10] = { 49,38,65,97,76,13,27,49,55,04};
	Bubblesort(a, 10);
	for (auto v : a)
		cout << v << " ";
	cout << endl;
	system("pause");
	return 0;
}

三、shell排序

#define _CRT_SECURE_NO_WARNINGS



#include<iostream>
#include<string>
#include<vector>
#include<fstream>
#include<list>



using std::cin;
using std::cout;
using std::endl;
using std::ifstream;
using std::ofstream;
using std::string;
using std::vector;
using std::pair;
using std::list;

void Shellsort(int *a, int len)
{
	int temp;
	for (int incr = len / 2; incr > 0; incr /= 2)
	{
		for (int i = incr; i < len; i++)
		{
			for (int j = i; j - incr >= 0; j -= incr)
			{
				if (a[j] < a[j - incr])
				{
					temp = a[j - incr];
					a[j - incr] = a[j];
					a[j] = temp;
				}
				else
					break;
			}
		}
	}
}

int main(int argc, char * argv[])
{
	

	int a[10] = { 49,38,65,97,76,13,27,49,55,04};
	Shellsort(a, 10);
	for (auto v : a)
		cout << v << " ";
	cout << endl;
	system("pause");
	return 0;
}

四、选择排序

#define _CRT_SECURE_NO_WARNINGS



#include<iostream>
#include<string>
#include<vector>
#include<fstream>
#include<list>



using std::cin;
using std::cout;
using std::endl;
using std::ifstream;
using std::ofstream;
using std::string;
using std::vector;
using std::pair;
using std::list;
using std::swap;

void Selectsort(int *a, int len)
{
	bool F = false;
	int max;
	for (int i = 0; i < len-1; i++)
	{
		max=0;
		F = false;
		
		for (int j = 1; j < len - i; j++)
		{
			
			if (a[max] <= a[j])
			{
				max = j;

			}
			else
				F = true;
			
		}
	
		if (F == false)
			break;
		
		swap(a[max], a[len - i-1]);
		
		
	}
}

int main(int argc, char * argv[])
{
	

	int a[10] = { 49,38,65,97,76,13,27,49,55,04};
	Selectsort(a, 10);
	for (auto v : a)
		cout << v << " ";
	cout << endl;
	system("pause");
	return 0;
}

五、插入排序

#define _CRT_SECURE_NO_WARNINGS



#include<iostream>
#include<string>
#include<vector>
#include<fstream>
#include<list>



using std::cin;
using std::cout;
using std::endl;
using std::ifstream;
using std::ofstream;
using std::string;
using std::vector;
using std::pair;
using std::list;
using std::swap;

void Insertsort(int *a, int len)
{
	
	for (int i = 1; i < len; i++)
	{
		
		for (int j = i; j >0; j--)
		{
			
			if (a[j] < a[j - 1])
			{
				swap(a[j], a[j - 1]);

			}
			else
				break;
			
			
		}
		
	}
}

int main(int argc, char * argv[])
{
	

	int a[10] = { 49,38,65,97,76,13,27,49,55,04};
	Insertsort(a, 10);
	for (auto v : a)
		cout << v << " ";
	cout << endl;
	system("pause");
	return 0;
}

六、堆排序

#define _CRT_SECURE_NO_WARNINGS



#include<iostream>
#include<string>
#include<vector>
#include<fstream>
#include<list>



using std::cin;
using std::cout;
using std::endl;
using std::ifstream;
using std::ofstream;
using std::string;
using std::vector;
using std::pair;
using std::list;
using std::swap;

void Percdown(int *a, int len)
{
	int child;
	for (int i = (len - 1 - 1) / 2; i >= 0; i--)
	{
		for (int j = i; 2 * j + 1 < len; j = child)
		{
			child = 2 * j + 1;
			if (2 * j + 1<len - 1 && a[2 * j + 2] > a[2 * j + 1])
				child = 2 * j + 2;
			if (a[j] < a[child])
				swap(a[j], a[child]);
			else
				break;
		}

	}
}

void Heapsort(int *a, int len)
{
	Percdown(a, len);
	for (int i = 0; i <len - 1; i++)
	{
		swap(a[0], a[len - 1 - i]);
		Percdown(a, len - i - 1);


	}
}

int main(int argc, char * argv[])
{


	int a[10] = { 49,38,65,97,76,13,27,49,55,04 };
	Heapsort(a, 10);
	for (auto v : a)
		cout << v << " ";
	cout << endl;
	system("pause");
	return 0;
}

 

七、快速排序

#define _CRT_SECURE_NO_WARNINGS



#include<iostream>
#include<string>
#include<vector>
#include<fstream>
#include<list>



using std::cin;
using std::cout;
using std::endl;
using std::ifstream;
using std::ofstream;
using std::string;
using std::vector;
using std::pair;
using std::list;
using std::swap;

int median(int *a,int start,int end)
{
	int center = (start + end)/2;
	//冒泡排序
	if (a[start] > a[center])
		swap(a[start], a[center]);
	if (a[end - 1] < a[center])
		swap(a[end - 1], a[center]);
	if (a[start] > a[center])
		swap(a[start], a[center]);
	
	swap(a[end - 1], a[center]);
	return a[end - 1];
}

void Quicksort(int *a, int start,int end)
{
	if (end - start <= 1)
		return;
	
	else {
		int pivot = median(a, start, end);
		int i = start, j = end - 2;
		while (1)
		{
			while (a[i] < pivot)
				i++;
			while (a[j] >pivot)
				j--;
			if (i < j)
			{
				swap(a[i], a[j]);
			}	
			else
				break;
		}
		swap(a[i], a[end - 1]);
		Quicksort(a, start, i);
		Quicksort(a, i+1, end);

	}
	
	
}

int main(int argc, char * argv[])
{
	

	int a[10] = { 49,38,65,97,76,13,27,49,55,04};
	
	Quicksort(a,0, 10);
	for (auto v : a)
		cout << v << " ";
	cout << endl;
	system("pause");
	return 0;
}

 

c++ 排序
qq_43003160的博客
03-05 234
一、快速排序 #include<iostream> #include<string> using namespace std; void qiucksort(string &s,int begin,int end) { if (begin > end)return; int tmp = s[begin];//基准 int i = begin;//左 int j = end;//右 while (i != j) { while (s[j] >=
C++十大排序详解（包括变种优化）
最新发布
7.15之前尽量一天一更，更新C++，Java的相关代码知识（基础）
07-08 874
冒泡排序优化 1. 提前终止优化（标志位优化） 原理： 在每一轮遍历中，若未发生任何元素交换，说明数组已有序，可直接终止排序，避免无效遍历。 优点： 对部分有序的数组效率显著提升（时间复杂度可降为O(n)）。 简单易实现，仅需增加一个标志位。 2. 双向冒泡排序（鸡尾酒排序，Cocktail Shaker Sort） 原理： 在传统单方向冒泡的基础上，增加从右到左的逆向扫描，将较小的元素逐步移到左侧。每轮交替进行双向扫描，减少遍历次数。 优点： 适用于反向有序的数组（如完全降序），效率优于传统冒泡排
C++的排序
摸鱼中......
04-14 8514
C++十大排序1.快速排序2.插入排序3.选择排序4.冒泡排序5.归并排序6.堆排序7.计数排序8.桶排序9.基数排序10.希尔排序11.补充 稳定排序（排序前后两个相等的数的相对位置不变）：归并排序、冒泡排序、插入排序、基数排序； 非稳定排序：希尔排序、堆排序、选择排序、快速排序。 1.快速排序 快速排序采用分而治之的思想，选取基准值，第一次排序之后将小于等于基准值的值都放在该值前面，将大于等于基准值的值都放在该值后面，接下来对前面的和后面的再次进行快速排序，分而治之直到无法再“分”为止。 #incl
[排序]SORT QSORT
ACM是什么？可以吃吗
03-23 1197
一.sort函数的用法    排序是一种经常要用到的操作。如果每次都自己写个冒泡之类的O(n^2)排序，不但程序容易超时，而且浪费宝贵的比赛时间，还很有可能写错。STL里面有个sort函数，可以直接对数组排序，复杂度为n*log2(n)。使用这个函数，需要包含头文件。     这个函数可以传两个参数或三个参数。第一个参数是要排序的区间首地址，第二个参数是区间尾地址的下一地址。也就是说，
C++排序
qq_43535469的博客
03-22 154
冒泡排序 从第一个数字开始 依次和相邻的数字做对比 更大的那个就放右边 更小的放左边 这样就会将整个序列中最大的一个数放在最右边 就像浮出水面一样 然后再对剩下的序列进行相同操作 void bubbleSort(int *a) { for (int i = 0; i < 10; i++) { for (int j = 0; j < 10-i; j++) { if (a[j] > a[j + 1]) swap(a[j], a[j + 1]); } } } 插
C++实现各种排序算法.zip
10-10
本资料包"**C++实现各种排序算法.zip**"提供了C++语言实现的多种排序算法，这对我们深入理解和运用这些算法具有重要意义。 首先，让我们探讨一下**排序算法**的基本概念。排序是指将一组数据按照特定顺序排列的过程...
C++实现各种排序算法类汇总
09-04
C++实现各种排序算法类汇总 C++实现各种排序算法类是一种常用的算法实现方式，旨在提供多种排序算法的实现代码，以便开发者可以根据实际情况选择合适的排序算法。下面是对该实现的详细介绍： 一、直接插入排序 ...
C++实现各种排序算法排序性能的比较，如果有更好的算法，替换相应的算法就可以
11-16
标题中的"C++实现各种排序算法排序性能的比较"指出，这是一个关于C++编程的项目，其核心内容是对比不同排序算法的效率。排序是计算机科学中的基础问题，它在数据分析、数据库管理等领域有着广泛的应用。C++作为一种...
【10种排序算法 (C++实现)】
QTSYlyt的博客
07-19 1281
算法学习中, 这里给出了常用的10种排序算法的C++代码.
C++中的排序
5431的专栏
04-11 1193
在C++ stl中带有 排序的函数，头文件是#include sort 函数有默认的三个参数 （1） 第一个参数是要排序的数组的起始地址。 （2） 第二个参数是要排序的结束的地址。 （3） 第三个参数是排序的方法，可以从小到大也可以从大到小，如果没写，默认是升序排列。 #include #include using namespace std; int main() { int
c++语言实现排序
02-23
该程序使用C++语言，实现了排序功能。里面的代码功能都有详细的讲解。
C++实现各种排序算法
KI的博客
08-21 9324
c++实现插入排序、选择排序和交换排序
c++实现各种排序算法
weixin_44678052的博客
08-16 263
冒泡排序 #if 1 #include<iostream> using namespace std; int main() { int t[10] = { 2,5,7,3,1,8,6,3,7,0 }; int flag=0; for (int i = 1; i < 10; i++) { for (int j = 0; j < 10 - i; j++) ...
C++实现各种排序（快速、归并、冒泡、选择、堆排序）
Echo1214_Xie的博客
06-29 597
1. 快速排序 使用递归的方法。选取数组中任意一个值key作为比较（通常选取第一个值），然后数组先从后往前寻找第一个小于key的值，再从前往后寻找第一个大于key的值，交换这两个值的位置，继续前面的寻找。然后把第一个值（key）交换到两个子数组中间位置。现在两子数组，左边都小于key，右边都大于key。左右子数组再进行递归。 时间复杂度平均O(nlogn),最坏是Olog(n^2). //...
c++排序
EvenHong的博客
09-06 176
1.冒泡排序： void sortpaopao(int a[],int length) { int loop; for (loop = 0; loop < length - 1; loop++) { for (int i = 0; i < length - loop - 1; i++) { if (a[i]>a[i+1]) { int tmp = a[i]; a[i] ...
c++各种排序算法实现
weixin_40599276的博客
09-14 204
#include<iostream> #include<unordered_map> #include<string> #include<vector> using namespace std; //含有跳跃式交换的排序算法，都是不稳定的算法 //---------交换类------- //冒泡排序---稳定的排序、最好n、平均n^2、最坏n^2 ...
各种排序算法的c++代码实现
liyongqi_的博客
04-22 1024
下面是c++实现选择排序、冒泡排序、插入排序、基数排序、快速排序、归并排序的代码，能够显示各种排序算法的中间过程。#include <iostream> #include <string.h> #include <windows.h> using namespace std; //下面的函数是交换大小void swap(int &x, int &y) { int temp = x;
用C++实现七种排序算法，可选择排序方法，简单易懂。
kanty之家
03-04 1381
最近学习算法，先从简答的开始学起，用C++做了一个实现七种排序算法的界面，可选择想要用的选择算法，不过，由于时间仓促，没有来得及优化和代码注释，后期还会加上代码注释，随便优化一下代码，提高执行效率； /************************************************************************* > File Name: sort.cpp
C++各种排序算法实现详解及源码
在详细解读给定文件信息之前，我们首先要明确文件标题“C++实现各种排序算法.zip”所代表的含义。该标题直接指出了这个压缩包内容的核心：一个关于如何用C++语言实现多种排序算法的项目或代码集合。排序算法是计算机...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值