C++常见排序算法

最新推荐文章于 2024-08-14 23:43:40 发布
最新推荐文章于 2024-08-14 23:43:40 发布
阅读量192 收藏 2
点赞数
分类专栏： C++ 文章标签： 排序算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43433042/article/details/107675647
版权

1. 直接插入排序

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

int main() {
	int n;
	cin >> n;
	vector<int> arr(n + 1, 0);
	for (int i = 1; i <= n; ++i)
		cin >> arr[i];
	for (int i = 2; i <= n; ++i)
		if (arr[i] < arr[i - 1]) {
			arr[0] = arr[i];
			int j;
			for (j = i - 1; arr[0] < arr[j]; j--)
				arr[j + 1] = arr[j];
			arr[j + 1] = arr[0];
		}
	for (int i = 1; i <= n; ++i)
		cout << arr[i] << " ";
	cout << endl;
	return 0;
}

2. 二分插入排序

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

int main() {
	int n;
	cin >> n;
	vector<int> arr(n + 1, 0);
	for (int i = 1; i <= n; ++i)
		cin >> arr[i];
	for (int i = 2; i <= n; ++i) {
		arr[0] = arr[i];
		int low = 1, high = i - 1;
		while (low <= high) {
			int mid = low + (high - low) / 2;
			if (arr[0] < arr[mid])
				high = mid - 1;
			else
				low = mid + 1;
		}
		int j;
		for (j = i - 1; j > high; j--)
			arr[j + 1] = arr[j];
		arr[j + 1] = arr[0];
	}
	for (int i = 1; i <= n; ++i)
		cout << arr[i] << " ";
	cout << endl;
	return 0;
}
}

3. 希尔排序

在这里插入图片描述

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

void insertI(vector<int>& arr, int gap, int i) {   //插入排序
	int inserted = arr[i];
	int j;
	for (j = i - gap; j >= 0 && inserted < arr[j]; j -= gap)
		arr[j + gap] = arr[j];
	arr[j + gap] = inserted;
}

void shellSort(vector<int>& arr) {    //分组
	int n = arr.size();
	for (int gap = n / 2; gap > 0; gap /= 2)
		for (int i = gap; i < n; ++i)
			insertI(arr, gap, i);
}

int main() {
	int n;
	cin >> n;
	vector<int> arr(n, 0);
	for (int i = 0; i < n; ++i)
		cin >> arr[i];
	shellSort(arr);
	for (int i = 0; i < n; ++i)
		cout << arr[i] << " ";
	cout << endl;
	return 0;
}

4. 冒泡排序

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

int partition(vector<int>& arr, int low, int high) {    //找分割点
	int pivot = arr[low];
	while (low < high) {
		while (low < high && arr[high] >= pivot)
			high--;
		arr[low] = arr[high];
		while (low < high && arr[low] <= pivot)
			low++;
		arr[high] = arr[low];
	}
	arr[low] = pivot;
	return low;
}

void quickSort(vector<int>& arr, int low, int high) {   
	if (low < high) {
		int pivotloc = partition(arr, low, high);
		quickSort(arr, low, pivotloc - 1);
		quickSort(arr, pivotloc + 1, high);
	}
}

int main() {
	int n;
	cin >> n;
	vector<int> arr(n, 0);
	for (int i = 0; i < n; ++i)
		cin >> arr[i];
	quickSort(arr, 0, n - 1);
	for (int i = 0; i < n; ++i)
		cout << arr[i] << " ";
	cout << endl;
	return 0;
}

6. 简单选择排序

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

int main() {
	int n;
	cin >> n;
	vector<int> arr(n, 0);
	for (int i = 0; i < n; ++i)
		cin >> arr[i];
	for (int i = 0; i < n - 1; ++i) {    //找到最小数的索引
		int index = i;
		for (int j = i + 1; j < n; ++j)
			if (arr[j] < arr[index])
				index = j;
		if (index != i) {
			int temp = arr[i];
			arr[i] = arr[index];
			arr[index] = temp;
		}
	}
	for (int i = 0; i < n; ++i)
		cout << arr[i] << " ";
	cout << endl;
	return 0;
}

7. 堆排序（小根堆）

小根堆排序后的输出是降序排列

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

void minHeapDown(vector<int>& arr, int start, int end) {
	int cur = start;
	int left = 2 * cur + 1;
	int temp = arr[cur];
	for (; left <= end; cur = left, left = 2 * left + 1) {
		if (left < end && arr[left] > arr[left + 1])
			left++;
		if (temp <= arr[left])
			break;
		else {
			arr[cur] = arr[left];
			arr[left] = temp;
		}
	}
}

void heapSortIncr(vector<int>& arr, int n) {
	int temp = 0;
	for (int i = n / 2 - 1; i >= 0; i--)
		minHeapDown(arr, i, n - 1);
	for (int i = n - 1; i > 0; i--) {
		temp = arr[0];
		arr[0] = arr[i];
		arr[i] = temp;
		minHeapDown(arr, 0, i - 1);
	}
}

int main() {
	int n;
	cin >> n;
	vector<int> arr(n, 0);
	for (int i = 0; i < n; ++i)
		cin >> arr[i];
	heapSortIncr(arr, n);
	for (int i = 0; i < n; ++i)
		cout << arr[i] << " ";
	cout << endl;
	return 0;
}

8. 堆排序（大根堆）

大根堆排序后的输出时升序排列

#include <iostream>
#include <vector>
using namespace std;
void maxHeapDown(vector<int>& arr, int start, int end) {
	int cur = start;
	int left = 2 * cur + 1;
	int temp = arr[cur];
	for (; left <= end; cur = left, left = 2 * left + 1) {
		if (left < end && arr[left] < arr[left + 1])
			left++;
		if (temp >= arr[left])
			break;
		else {
			arr[cur] = arr[left];
			arr[left] = temp;
		}
	}
}
void heapSortIncr(vector<int>& arr, int n) {
	int temp = 0;
	for (int i = n / 2 - 1; i >= 0; i--)
		maxHeapDown(arr, i, n - 1);
	for (int i = n - 1; i > 0; i--) {
		temp = arr[0];
		arr[0] = arr[i];
		arr[i] = temp;
		maxHeapDown(arr, 0, i - 1);
	}
}
int main() {
	int n;
	cin >> n;
	vector<int> arr(n, 0);
	for (int i = 0; i < n; ++i)
		cin >> arr[i];
	heapSortIncr(arr, n);
	for (int i = 0; i < n; ++i)
		cout << arr[i] << " ";
	cout << endl;
	return 0;
}

9. 归并排序

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

void Merge(vector<int>& arr, int low, int mid, int high) {   //归并
	int i = low, j = mid + 1, k = 0;   //将数组分成两部分
	vector<int> temp(high - low + 1);  //开辟一个临时数组
	while (i <= mid && j <= high) {    //
		if (arr[i] <= arr[j])
			temp[k++] = arr[i++];
		else
			temp[k++] = arr[j++];
	}
	while (i <= mid)
		temp[k++] = arr[i++];
	while (j <= high)
		temp[k++] = arr[j++];
	k = 0;
	while(low<=high)
		arr[low++] = temp[k++];
}

void mergeSort(vector<int>& arr, int low, int high) {
	if (low < high) {
		int mid = low + (high - low) / 2;
		mergeSort(arr, low, mid);
		mergeSort(arr, mid + 1, high);
		Merge(arr, low, mid, high);
	}
}

int main() {
	int n;
	cin >> n;
	vector<int> arr(n, 0);
	for (int i = 0; i < n; ++i)
		cin >> arr[i];
	mergeSort(arr, 0, n-1);
	for (int i = 0; i < n; ++i)
		cout << arr[i] << " ";
	cout << endl;
	return 0;
}

10.基数排序

在这里插入图片描述

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

void radixSort(vector<int>& arr, int n) {
	int max = arr[0];
	for (int i = 1; i < n; ++i)
		max = max > arr[i] ? max : arr[i];  //找最大值
	for (int i = 1; max / i > 0; i *= 10) {  //按个位入桶->按十位入桶->...
		vector<vector<int>> buckets(10, vector<int>(n, -1));  //10个桶
		for (int j = 0; j < n; ++j) {
			int num = arr[j] / i % 10;
			buckets[num][j] = arr[j];
		}
		int index = 0;
		for (int j = 0; j < 10; ++j)  //按个位排序取出->按十位排序取出->...
			for (int k = 0; k < n; ++k)
				if (buckets[j][k] != -1)
					arr[index++] = buckets[j][k];
	}
}

int main() {
	int n;
	cin >> n;
	vector<int> arr(n, 0);
	for (int i = 0; i < n; ++i)
		cin >> arr[i];
	radixSort(arr, n);
	for (int i = 0; i < n; ++i)
		cout << arr[i] << " ";
	cout << endl;
	return 0;
}
锁在琥珀里的时光
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
十大经典排序算法
nmslqwq的博客
10-10 660
排序算法是《数据结构与算法》中最基本的算法之一。 排序算法可以分为内部排序和外部排序，内部排序是数据记录在内存中进行排序，而外部排序是因排序的数据很大，一次不能容纳全部的排序记录，在排序过程中需要访问外存。常见的内部排序算法有：插入排序、希尔排序、选择排序、冒泡排序、归并排序、快速排序、堆排序、基数排序等。用一张图概括： 关于时间复杂度 平方阶 (O(n2)) 排序 各类简单排序：直接插入、直接...
c++常见的排序算法
qq_19457459的博客
10-02 168
1959年Shell发明，第一个突破O(n2)的排序算法，是简单插入排序的改进版。它与插入排序的不同之处在于，它会优先比较距离较远的元素。希尔排序又叫缩小增量排序。
二分查找 c++
qq_46606018的博客
03-15 208
二分查找 /* 功能：二分查找 作者：ltj 创作时间：2021/3/15 */ #include<iostream> using namespace std; int BSearch(int list[],int key,int low,int high){ //递归法 数组，关键字，第一个位置数组下标，最后位置数组下标 if(low<=high){ int mid=(high+low)/2; if(key==list[mid]){ //当要查找的值等于中间值时
常见的几种排序算法（c++）
热门推荐
low5252的博客
03-12 1万+
常见的几种排序算法（c++）一、冒泡排序二、插入排序三、选择排序四、归并排序五、希尔排序六、快速排序七、堆排序八、基数排序1.LSD(低位到高位的排序)2.MSD(高位到低位排序)算法比较 一、冒泡排序 1、算法思想 冒泡排序是一种简单的排序算法，通过循环遍历，将临近的两个元素进行比较，满足排序规则时，进行下一组元素对比，当不满足排序规则时，将两个元素交换位置，再继续进行下一组元素对比，确保最大的...
C++实现五种常见排序算法
weixin_39318565的博客
06-20 5312
排序算法在工作和面试中都经常用到这里是常见的几种算法的C++实现
十大常见排序算法（C++版本代码）
qq_43036667的博客
04-24 1610
冒泡排序（Bubble sort）是一种交换排序，它的基本思想是：两两比较相邻元素的关键字，如果反序则交换，直到没有反序的记录（数据元素）为止。时间复杂度为O(n^2)，空间复杂度为O(1)稳定算法步骤比较相邻的元素。如果第一个比第二个大，就交换它们两个；对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数；针对所有的元素重复以上的步骤，除了最后一个；重复步骤1~3，直到排序完成。
C++常用排序算法
qq_42123832的博客
02-12 1211
排序算法 语言 C/C++ 数据结构 vector 数据类型 int 交换操作 函数 void exchange (int left, int right); //之所以这里使用一个函数来表示交换操作，是为了将这个操作抽象化，遇到具体问题，只需重写该函数即可 void exchange (int& left, int& right) { left = l...
C++常见八大排序算法
01-24
Hoare提出的快速排序是一种非常高效的排序算法，它采用分治法，选取一个基准值，将数组分为两部分，一部分的所有元素都比基准值小，另一部分的所有元素都比基准值大，然后再对这两部分进行排序。快速排序的平均时间...
c++排序算法-冒泡排序
11-08
冒泡排序是一种基础且经典的计算机科学排序算法，尤其在C++编程中常见。它通过不断地比较相邻元素并根据需要进行交换，逐步将较大的元素“冒泡”到序列的末尾，从而实现升序排列。这一过程可以理解为一个逐层推进的...
常见排序算法C++实现
01-23
在编程领域，排序算法是数据结构与算法学习中的基础部分，尤其在C++这样的系统级编程语言中，理解和掌握各种排序算法的实现至关重要。这里我们将深入探讨标题中提到的五种排序算法——归并排序、快速排序、希尔排序...
C++实现常用排序算法
07-15
C++实现常用排序算法，包括冒泡、选择、插入、归并、快排和堆排。代码完整可运行。
C++实现各种排序算法.zip
10-10
Hoare提出的高效排序算法，采用分治法，通过一趟排序将待排记录分隔成独立的两部分，其中一部分记录的关键字均比另一部分的关键字小，然后分别对这两部分记录继续进行排序，以达到整个序列有序。 5. **归并排序...
基于C++冒泡排序法
12-19
冒泡排序法是一种基础但重要的排序算法，尤其在学习数据结构和算法的初期阶段，它为理解排序原理提供了直观的示例。C++是广泛应用于系统编程、应用编程、游戏开发等多个领域的强大编程语言，因此用C++实现冒泡排序是...
c++十大经典排序算法
客舟中
12-28 6517
代码 1 冒泡排序 冒泡排序是一种简单直观的入门排序算法。它的原理就是从第一个元素开始，与后面的元素逐个比较，如果顺序不对就交换，直到没有可比较的元素为止。 1 // 冒泡排序 2 void BublingSort(int *arr, int len) 3 { 4 if(len == 0) 5 { 6 return; 7 } 8 std::cout<<"冒泡排序"<<std::endl; 9 for(i
【C++】常见的几种排序算法
zdb
11-02 6264
借用了这位大哥的图片：链接，也可以看此博客讲解直接插入排序。 这位大哥做了每种排序的讲解博客，很不错强推。。 此博客只为方便学习，造福人类。 （1）冒泡排序 冒泡排序的思路是数小的像泡泡一样冒出来，反过来我们可以理解为，数大的像石头一样沉下去。 我们遍历数组，从左到右，若右边的数比左边的大，则交换。 第一遍：最大的数沉下去 第二遍：第二大的数沉在倒数第二个位置 … 版本二为常见常用版本，版本三在二的基础上优化，避免了不需要的排序 class Sloution { public: //冒泡：时间复杂度O
十大经典排序算法（C++实现）
m0_60935443的博客
03-22 9307
0、算法分类 排序算法是《数据结构与算法》中最基本的算法之一。 十种常见排序算法可以分为两大类： 比较类排序：通过比较来决定元素间的相对次序，时间复杂度为 O(nlogn)～O(n²)。 非比较类排序：不通过比较来决定元素间的相对次序，其时间复杂度可以突破 O(nlogn)，以线性时间运行。 名次解释： 时间/空间复杂度：描述一个算法执行时间/占用空间与数据规模的增长关系。 n：待排序列的个数。 k：“桶”的个数（上面的三种非比较类排序都是基于“桶”的思想实
用C++实现十大经典排序算法
billy的博客
01-04 8168
排序算法可以分为内部排序和外部排序，内部排序是数据记录在内存中进行排序，而外部排序是因排序的数据很大，一次不能容纳全部的排序记录，在排序过程中需要访问外存。
C++八种排序算法万字详解
我的博客
06-04 7578
哈喽，今天我来总结一下C++中的8中排序方法，这些排序在实际开发中能起到一些作用，也可以锻炼你的算法头脑。我也好长时间没上热榜了，这次准备做一个非常详细🔎的总结，看看能不能上热榜。既然叫排序算法，肯定要排序。我们要实现的效果是输入几个数，输出升序（或降序）排序后的结果，并找到时间复杂度最低的算法，应用到实际开发中。冒泡排序主要思路就是遍历数组，比较两个相邻的元素，也就是 arr[j] 和 arr[j+1] ，如果顺序错误就用 swap 函数或空杯交换，交换这两个元素。举个例子，数组是 a[5]={2,1,.
排序算法----希尔排序
最新发布
2301_80028974的博客
08-14 379
希尔排序，又称“”（Diminishing Increment Sort），是由美国计算机科学家Donald Shell于1959年提出的一种排序算法。它是直接插入排序算法的一种改进版本，旨在通过减少插入排序中的交换操作和比较次数，从而提高排序效率。希尔排序通过将待排序的数组元素分成多个子序列，然后对每个子序列进行直接插入排序，最后当整个序列“基本有序”时，再进行一次直接插入排序来完成排序过程。
C++实现常见算法：排序方法详解
本资源包含了四种常见的排序算法，分别是：直接插入排序、希尔排序、选择排序和冒泡排序，以及归并排序。这些排序算法在实际编程中具有重要的应用价值，因为它们是数据处理和算法设计的基础。 1. **直接插入排序**:...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值