C++算法——基本的排序算法（插入、选择、冒泡、梳排序）

已于 2022-02-09 10:08:27 修改
阅读量114 收藏 1
点赞数 1
文章标签： 排序算法 c++
于 2021-06-12 23:32:05 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/nicholasytz/article/details/117856871
版权 
本文为作者学习笔记
欢迎交流讨论，喜欢的话点个赞吧

欢迎去看我的主页: NicholasYe’s Hompage.

插入排序

  • 原理：将一个元素放在合适的位置，并将其他的元素向前或向后一起移动一个位置

步骤：

  1. 从data[1]开始，因为只有一个元素的数组是已排序的
  2. temp存储data[i],用于将较小值放置于数组前方
  3. 从data[i]开始，以data[j]给data[j-1]赋值的方式向数列后方复制
  4. 结束条件：temp比data[j-1]大或者已经复制到数列最前方
  5. 替换较小的值
#include <iostream>
using namespace std;

void Insertation(int data[], int n, int way)
{
	//升序排序
	if (way == 0)
	{
		//从data[1]开始，因为只有一个元素的数组是已排序的
		for (int i = 1, j; i < n; i++)
		{
			//temp存储data[i],用于将较小值放置于数组前方
			int temp = data[i];

			//从data[i]开始，以data[j]给data[j-1]赋值的方式向数列后方复制
			//结束条件：temp比data[j-1]大或者已经复制到数列最前方
			for (j = i; j > 0 && temp < data[j - 1]; j--)
				data[j] = data[j - 1];

			//替换较小的值
			data[j] = temp;
		}
	}
	//降序排序
	else if (way == 1)
	{
		for (int i = 1, j; i < n; i++)
		{
			int temp = data[i];
			for (j = i; j > 0 && temp > data[j - 1]; j--)
				data[j] = data[j - 1];
			data[j] = temp;
		}
	}
}

int main()
{
	//定义数组大小
	const int Num = 20;

	int Arr[Num] = { 92,57,42,69,89,16,24,44,52,11,73,9,45,3,64,29,87,26,78,31 };
	cout << "排序前：";
	for (int i = 0; i < Num; i++)
		cout << Arr[i] << " ";
	cout << endl;

	//升序排序
	Insertation(Arr, Num, 0);
	cout << "排序后：";
	for (int i = 0; i < Num; i++)
		cout << Arr[i] << " ";
	cout << endl;

	//降序排序
	Insertation(Arr, Num, 1);
	cout << "排序后：";
	for (int i = 0; i < Num; i++)
		cout << Arr[i] << " ";
	cout << endl;

	system("pause");
	return 0;
}

选择排序

  • 原理：从头开始，搜寻数组里面的最小值，并将它放在最小的位置

步骤：

  1. 对第i个数字进行替换
  2. 在i后面的数字中进行搜寻，搜索更小的数字，并进行替换

改进策略：
如果该值与最小值不相同则交换（此步骤可以减小交换/赋值次数）

#include <iostream>
using namespace std;

void Selectionsort(int data[], int n, int way)
{
	//升序排序
	if (way == 0)
	{
		//对第i个数字进行替换
		for (int i = 0, j, least; i < n - 1; i++)
		{
			//在i后面的数字中进行搜寻，搜索更小的数字
			for (j = i + 1, least = i; j < n; j++)
			{
				if (data[j] < data[least])
					least = j;
			}

			//如果该值与最小值不相同则交换（此步骤可以减小交换/赋值次数）
			if (least != i)
			{
				//将更小的数字与该数字进行调换
				int temp = data[least];
				data[least] = data[i];
				data[i] = temp;
			}
		}
	}
	//降序排序
	else if (way == 1)
	{
		for (int i = 0, j, least; i < n - 1; i++)
		{
			for (j = i + 1, least = i; j < n; j++)
			{
				if (data[j] > data[least])
					least = j;
			}
			if (least != i)
			{
				int temp = data[least];
				data[least] = data[i];
				data[i] = temp;
			}
		}
	}
}

int main()
{
	//定义数组大小
	const int Num = 20;

	int Arr[Num] = { 92,57,42,69,89,16,24,44,52,11,73,9,45,3,64,29,87,26,78,31 };
	cout << "排序前：";
	for (int i = 0; i < Num; i++)
		cout << Arr[i] << " ";
	cout << endl;

	//升序排序
	Selectionsort(Arr, Num, 0);
	cout << "排序后：";
	for (int i = 0; i < Num; i++)
		cout << Arr[i] << " ";
	cout << endl;

	//降序排序
	Selectionsort(Arr, Num, 1);
	cout << "排序后：";
	for (int i = 0; i < Num; i++)
		cout << Arr[i] << " ";
	cout << endl;

	system("pause");
	return 0;
}

冒泡排序

  • 原理：通过比较将较小的值一次一次换到最前方

步骤：

  1. 从第一个次交换开始，总共进行n-1次交换
  2. 从最后一个数字开始向上排序
  3. 将该数字与前面一个数字进行比较，若比前面小则交换

改进策略：
bool类型做标记，若有一次没有交换，即该数字与前面一个数字相等，则跳过一个回合

#include <iostream>
using namespace std;

void Bubblesort(int data[], int n, int way)
{
	//升序排序
	if (way == 0)
	{
		//bool类型做标记，若有一次没有交换，即该数字与前面一个数字相等，则跳过一个回合
		//该行为可以减少冒泡排序的交换次数
		bool change = true;
		//从第一个次交换开始，总共进行n-1次交换
		for (int i = 0; i < n - 1&&change; i++)
		{
			//从最后一个数字开始交换，将change默认为false
			for (int j = n - 1,change= false ; j > i; --j)
			{
				//将该数字与前面一个数字进行比较，若比前面小则交换
				if (data[j] < data[j - 1])
				{
					int temp = data[j];
					data[j] = data[j - 1];
					data[j - 1] = temp;
					//发生交换，change改为true
					change = true;
				}
			}
		}
	}
	//降序排序
	else if (way == 1)
	{
		bool change = true;
		for (int i = 0; i < n - 1 && change; i++)
		{
			for (int j = n - 1, change = false; j > i; --j)
			{
				if (data[j] > data[j - 1])
				{
					int temp = data[j];
					data[j] = data[j - 1];
					data[j - 1] = temp;
					change = true;
				}
			}
		}
	}
}

int main()
{
	//定义数组大小
	const int Num = 20;

	int Arr[Num] = { 92,57,42,69,89,16,24,44,52,11,73,9,45,3,64,29,87,26,78,31 };
	cout << "排序前：";
	for (int i = 0; i < Num; i++)
		cout << Arr[i] << " ";
	cout << endl;

	//升序排序
	Bubblesort(Arr, Num, 0);
	cout << "排序后：";
	for (int i = 0; i < Num; i++)
		cout << Arr[i] << " ";
	cout << endl;

	//降序排序
	Bubblesort(Arr, Num, 1);
	cout << "排序后：";
	for (int i = 0; i < Num; i++)
		cout << Arr[i] << " ";
	cout << endl;

	system("pause");
	return 0;
}

梳排序

  • 原理：梳排序并不是一种单独的排序方式，而是在排序之前先对数据预处理，将一些大的数字放在后面，小的数字放在前面，处理完后再进行排序，本例中用的是冒泡排序。

步骤：

  1. 初始化步长
  2. 因子s=1.3用来确定元素的位置之间的间距，减少step的大小直至step/1.3<1时结束
  3. data[j]与data[j-step]比较，并进行位置调换
#include <iostream>
using namespace std;

void Combsort(int data[],const int n, int way)
{
	//升序排序
	if (way == 0)
	{
		//初始化步长
		int step = n, j, k;
		//因子s=1.3用来确定元素的位置之间的间距（Box和Lacey1991）
		//直至step/1.3<1时结束
		while ((step = int(step / 1.3)) > 1)
		{
			//data[j]与data[j-step]比较，并进行位置调换
			for (j = n - 1; j >= step; j--)
			{
				k = j - step;
				if (data[j] < data[k])
				{
					int temp = data[j];
					data[j] = data[k];
					data[k] = temp;
				}
			}
		}

		//冒泡排序
		bool change = true;
		for (int i = 0; i < n - 1 && change; i++)
		{
			for (int j = n - 1, change = false; j > i; --j)
			{
				if (data[j] < data[j - 1])
				{
					int temp = data[j];
					data[j] = data[j - 1];
					data[j - 1] = temp;
					change = true;
				}
			}
		}
	}
	//降序排序
	else if (way == 1)
	{
		int step = n, j, k;
		while ((step = int(step / 1.3)) > 1)
		{
			for (j = n - 1; j >= step; j--)
			{
				k = j - step;
				if (data[j] > data[k])
				{
					int temp = data[j];
					data[j] = data[k];
					data[k] = temp;
				}
			}
		}
		bool change = true;
		for (int i = 0; i < n - 1 && change; i++)
		{
			for (int j = n - 1, change = false; j > i; --j)
			{
				if (data[j] > data[j - 1])
				{
					int temp = data[j];
					data[j] = data[j - 1];
					data[j - 1] = temp;
					change = true;
				}
			}
		}
	}
}

int main()
{
	//定义数组大小
	const int Num = 20;

	int Arr[Num] = { 92,57,42,69,89,16,24,44,52,11,73,9,45,3,64,29,87,26,78,31 };
	cout << "排序前：";
	for (int i = 0; i < Num; i++)
		cout << Arr[i] << " ";
	cout << endl;

	//升序排序
	Combsort(Arr, Num, 0);
	cout << "排序后：";
	for (int i = 0; i < Num; i++)
		cout << Arr[i] << " ";
	cout << endl;

	//降序排序
	Combsort(Arr, Num, 1);
	cout << "排序后：";
	for (int i = 0; i < Num; i++)
		cout << Arr[i] << " ";
	cout << endl;

	system("pause");
	return 0;
}

请在转载文章过程中明确标注文章出处！尊重原创，尊重知识产权，谢谢！

NicholasYTZ
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
C/C++学习教程：C语言排序算法—插入排序算法
C语言C++学习俱乐部：765860056
10-24 1017
前言：插入排序算法是所有排序方法中最简单的一种算法，其主要的实现思想是将数据按照一定的顺序一个一个的插入到有序的表中，最终得到的序列就是已经排序好的数据。 直接插入排序是插入排序算法中的一种，采用的方法是：在添加新的记录时，使用顺序查找的方式找到其要插入的位置，然后将新记录插入。 很多初学者所说的插入排序，实际上指的就是直接插入排序算法，插入排序算法还包括折半插入排序、2-路插入排序，表插入排序和希尔排序等。 直接插入排序的基本操作是将一个记录插入到已经排好的有序表中。 先选定一个位置..
C++实现交换排序算法（冒泡排序、快速排序）
qq_38222051的博客
11-01 3547
排序算法分为五大类，一共是有九种，如下： 插入类：直接插入排序、折半插入排序、希尔排序 交换类：冒泡排序、快速排序 选择类：简单选择排序、堆排序 归并类：二路归并排序 基数类：多关键字排序 九种算法的时间复杂度、空间复杂度和稳定性小结如下： 本文放出选择算法的两种排序算法代码。 冒泡排序 void BubbleSort(int R[], int n) { int i, j, temp, flag; cout << endl << "冒泡排序：" << endl;
C++多个数字从头到尾调换顺序
qq_46628334的博客
06-05 1564
原理很多人懂，看代码就看得懂不用我说上代码 #include <iostream> int main() { int a,c; std::cin>>a; int b[a]; for(int i=0;i<=a-1;i++)std::cin>>b[i]; for(int i=0;i<=a/2;i++) { c=b[i]; b[i]=b[a-1-i]; b[a-1-i]=c; } for(int i=0;i<=a-1;i++)s
【排序算法】插入排序(C++实现)
热门推荐
JimYe的专栏
03-10 5万+
插入排序的基本思想是每次将一个待排序的记录，按其关键字大小插入到前面已经排好序的子文件中的适当位置，直到全部记录插入完成为止。常见的插入排序有插入排序（Insertion Sort），希尔排序（Shell Sort），二叉查找树排序（Tree Sort），图书馆排序（Library Sort），Patience排序（Patience Sort）。下面介绍前两种： （一）直接插入排序 最差时间复
C++编程解析-算法-排序-冒泡排序算法
xingzhe_666的博客
10-25 471
题目： 输入n个数n,对这些数进行从小到大排列。n<=10000 冒泡排序算法解题程序： 测试样例及程序运行结果： 今天，我们讲到了另一个算法的知识-冒泡排序算法。想了解更多内容，请关注： NOIP信息学奥赛-33排序-冒泡排序（原价269，促销59.9） - 网易云课堂 https://study.163.com/course/courseMain.htm?courseId=120...
C++ 最简单排序算法 - 冒泡排序
喜欢编程，将自己会的知识分享给大家
03-18 1520
在写代码之前我们先了解一下什么是冒泡排序 解释: 冒泡排序的思想就是将第一个元素与第二个元素比较,如果第一个元素比第二个元素大,那么就将两者交换,并继续用第二个元素和第三个元素比较,在一个循环结束后,最大的元素会沉到数组的最右边,因此,下次循环就直接到倒数第二个元素为止,最后的一次循环就只剩第一个元素,至此,所有元素都排列完成。这种排序是按照从小到大排序,;还可以按照从大到小的顺序排列,即最大的向左沉 代码如下: sort.cpp #define _CRT_SECURE_NO_WAR.
C++实现冒泡排序算法（源代码）.pdf
04-30
本文介绍了使用C++语言实现冒泡排序的算法。冒泡排序是一种简单的排序算法，它通过相邻元素之间的比较和交换，将较大的元素逐步“冒泡”到数组的末尾，从而完成整个数组的排序。在实现的代码中，使用了两层循环：...
c++排序算法-冒泡排序
11-08
冒泡排序
C++ 排序算法之冒泡排序
07-25
C++ 排序算法之冒泡排序
C++排序算法之冒泡排序源码
06-29
C++排序算法之冒泡排序源码
C++实现双向冒泡排序算法
01-20
本文实例为大家分享了C++实现双向冒泡排序算法的具体代码，供大家参考，具体内容如下 一、概念（来源于百度百科） 传统冒泡算法原理 冒泡排序算法的运作如下：（从后往前） 1.比较相邻的元素。如果第一个比第二个大...
十种排序方法
2401_83427936的博客
06-11 1992
外层循环遍历数组中的每个元素（从第二个元素开始），内层循环则将当前元素（称为key）与其前面的元素进行比较，如果前面的元素比key大，则将它们向后移动一位，直到找到key的正确位置或者已经到达数组的开始。快速排序的基本思想是：选择一个基准元素（pivot），通过一趟排序将待排序的数据分割成独立的两部分，其中一部分的所有数据都比另一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。是插入排序的一种更高效的改进版本，也称为缩小增量排序。
leetcode 数组排序
weixin_38184628的博客
06-09 934
leetcode:排序算法包括基础的选择排序、插入排序、交换排序；也包括快速排序，堆排序，归并排序等。其中快速排序是交换排序的升级版；堆排序是选择排序的升级版。那插入排序有没有升级版呢，也是有的，是希尔排序，但是希尔排序的思想不好理解，所以本文中不涉及希尔排序。选择排序，插入排序，交换排序属于基础排序算法，时间复杂度是O(n * n)。快速排序和堆排序的时间复杂度是 O(nlogn)。
【C++】——Stack与Queue（含优先队列（详细解读）
m0_74092462的博客
06-09 989
优先队列是一种容器适配器，根据严格的弱排序标准，它的第一个元素总是它所包含的元素中最大的。stack是一种容器适配器，专门用在具有后进先出操作的上下文环境中，其删除只能从容器的一端进行元素的插入与提取操作。 队列是一种容器适配器，专门用于在FIFO上下文(先进先出)中操作，其中从容器一端插入元素，另一端提取元素。
C++——计算不同的非空子串个数
我发布的博客，快来抄答案吧
06-09 140
BCSP-X 11题 C++代码详解
LeetCode 算法：轮转数组c++
小金牛来了
06-09 670
LeetCode 算法：轮转数组c++
手搓顺序表（C语言）
最新发布
m0_62646213的博客
06-12 1232
顺序表头插头删，尾插尾删，任意位置插入删除的实现和优劣分析
【2024最新华为OD-C/D卷试题汇总】[支持在线评测] CPU算力分配(100分) - 三语言AC题解(Python/Java/Cpp)
清隆学长的博客
06-11 297
### 问题描述 K小姐是某公司运营部门的主管,最近她需要对公司的两组服务器进行算力分配。每组服务器有多个算力不同的 $CPU$,其中 $A$ 组第 $i$ 个 $CPU$ 的运算能力为 $A[i]$,而 $B$ 组第 $i$ 个 $CPU$ 的运算能力为 $B[i]$。一组服务器的总算力是各 $CPU$ 的算力之和。 为了让两组服务器的算力相等,K小姐允许从每组各选出一个 $CPU$ 进行一次交换。她希望从 $A$ 组服务器中选出算力尽可能小的 $CPU$ 来交换,你能帮她计算出应该选择哪两个 $CP
STL——Stacks容器
qq_74811378的博客
06-11 283
top() 函数返回对栈顶元素的引用. 举例,如下代码显现和清空一个堆栈。所有的这些操作可以被用于堆栈. 相等指堆栈有相同的元素并有着相同的顺序。size() 函数返当前堆栈中的元素数目。如当前堆栈为空，empty() 函数 返回。值压栈，使其成为栈顶的第一个元素。pop() 函数移除堆栈中最顶层元素。push() 函数将。
用c++实现直接插入排序、希尔排序、冒泡排序、快速排序算法
06-01
好的，下面是用C++实现直接插入排序、希尔排序、冒泡排序、快速排序算法的代码： 直接插入排序： ```cpp void insertSort(int arr[], int n) { for (int i = 1; i < n; i++) { for (int j = i; j > 0 && arr[j] < arr[j - 1]; j--) { swap(arr[j], arr[j - 1]); } } } ``` 希尔排序： ```cpp void shellSort(int arr[], int n) { for (int gap = n / 2; gap > 0; gap /= 2) { for (int i = gap; i < n; i++) { for (int j = i - gap; j >= 0 && arr[j] > arr[j + gap]; j -= gap) { swap(arr[j], arr[j + gap]); } } } } ``` 冒泡排序： ```cpp void bubbleSort(int arr[], int n) { for (int i = 0; i < n - 1; i++) { for (int j = 0; j < n - i - 1; j++) { if (arr[j] > arr[j + 1]) { swap(arr[j], arr[j + 1]); } } } } ``` 快速排序： ```cpp int partition(int arr[], int low, int high) { int pivot = arr[high]; int i = low - 1; for (int j = low; j <= high - 1; j++) { if (arr[j] < pivot) { i++; swap(arr[i], arr[j]); } } swap(arr[i + 1], arr[high]); return i + 1; } void quickSort(int arr[], int low, int high) { if (low < high) { int pi = partition(arr, low, high); quickSort(arr, low, pi - 1); quickSort(arr, pi + 1, high); } } ``` 以上就是用C++实现直接插入排序、希尔排序、冒泡排序、快速排序算法的代码。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值