常见排序算法之冒泡排序及其改进

最新推荐文章于 2024-07-24 22:13:06 发布

Surplus°

最新推荐文章于 2024-07-24 22:13:06 发布

阅读量1.8k

点赞数

分类专栏：数据结构文章标签：算法 c++

本文链接：https://blog.csdn.net/weixin_43373833/article/details/107778860

版权

数据结构专栏收录该内容

9 篇文章 1 订阅

订阅专栏

冒泡排序

冒泡排序(BubbleSort)以其“在排序过程中相邻元素不断交换，一些元素慢慢被换到最后，看起来就像是元素在冒泡一样”而得名，是一种简单的基于关键词比较的排序算法。

算法思想

假设有n个数据，依次比较相邻两个元素，如果反序则交换位置，直到没有反序为止。
以递增序为例，每次从头开始依次比较相邻的两个元素，如果后面一个元素比前一个要大，说明顺序不对，则将它们交换，本次循环完毕之后再次从头开始扫描，直到某次扫描中没有元素交换，说明每个元素都不比它后面的元素大，至此排序完成。

时间复杂度

最好时间复杂度O(n)
最坏时间复杂度O(n²)

经典冒泡排序

代码

void MySort::BubbleSort(std::vector<int>& nums) {
	int count1 = 0, count2 = 0;
	int numsSize = nums.size();
	for (int i = 0; i < numsSize - 1; i++) {
		for (int j = 0; j < numsSize -1 - i; j++) {
			count1++;
			if (nums[j] > nums[j+1]){
				count2++;
				int tmp = nums[j];
				nums[j] = nums[j+1];
				nums[j+1] = tmp;
			}
		}
	}
	std::cout << "比较次数：" << count1 << " 交换次数：" << count2 << std::endl;
}

测试

这里通过对十个随机数进行排序测试冒泡排序的结果。

#include <iostream>
#include <vector>
#include <cstdlib>//rand(),srand
#include <ctime>//time()
#include "print_data.h"
#include "mysort.h"

using namespace std;
int main()
{
	srand((int)time(NULL));//随机种子
	vector<int> nums,nums1;
	print_data printTest;
	MySort sortTest;
	for (int i = 0; i < 10; i++)
	{
		nums.push_back(rand() % 100);//生成0-99之间的随机数
	}
	/*nums.push_back(1);
	nums.push_back(0);
	nums.push_back(2);
	nums.push_back(3);
	nums.push_back(4);
	nums.push_back(5);
	nums.push_back(6);
	nums.push_back(7);
	nums.push_back(8);
	nums.push_back(9);
	nums1 = nums;*/
	printTest.printVector(nums);
	sortTest.BubbleSort(nums);
	printTest.printVector(nums);
	/*cout << endl;
	printTest.printVector(nums1);
	sortTest.BubbleSort1(nums1);
	printTest.printVector(nums1);*/
	system("pause");
	return 0;
}

结果

在这里插入图片描述

冒泡排序算法的改进

这里对经典冒泡排序进行改进，减少无效比较的次数。所谓无效比较就是当我们已知结果却还要去比较。如果我们多观察冒泡排序的中间过程，我们就会发现，末尾的一些元素在一定次数的扫描后已经到达最终位置了，再比较就会造成无效比较。改进方法是，记录下每次扫描中发生交换的最后一个元素位置，下一次扫描就到这里为止。

代码

void MySort::BubbleSort1(std::vector<int>& nums) {
	int count1 = 0, count2 = 0;
	int numsSize = nums.size();
	bool flag = true;
	for (int i = 0; (i < numsSize - 1) && flag; i++) {
		flag = false;//标记是否已经有序
		for (int j = 0; j < numsSize - 1 - i; j++) {
			count1++;
			if (nums[j] > nums[j + 1]) {
				count2++;
				flag = true;
				int tmp = nums[j];
				nums[j] = nums[j + 1];
				nums[j + 1] = tmp;
			}
		}
	}
	std::cout << "比较次数：" << count1 << " 交换次数：" << count2 << std::endl;
}

测试

#include <iostream>
#include <vector>
#include <cstdlib>//rand(),srand
#include <ctime>//time()
#include "print_data.h"
#include "mysort.h"

using namespace std;
int main()
{
	srand((int)time(NULL));//随机种子
	vector<int> nums,nums1;
	print_data printTest;
	MySort sortTest;
	for (int i = 0; i < 10; i++)
	{
		nums.push_back(rand() % 100);//生成0-99之间的随机数
	}
	/*nums.push_back(1);
	nums.push_back(0);
	nums.push_back(2);
	nums.push_back(3);
	nums.push_back(4);
	nums.push_back(5);
	nums.push_back(6);
	nums.push_back(7);
	nums.push_back(8);
	nums.push_back(9);
	nums1 = nums;*/
	/*printTest.printVector(nums);
	sortTest.BubbleSort(nums);
	printTest.printVector(nums);*/
	cout << endl;
	printTest.printVector(nums);
	sortTest.BubbleSort1(nums);
	printTest.printVector(nums);
	system("pause");
	return 0;
}

结果

在这里插入图片描述

改进算法与经典算法的比较

测试

下面用一个基本有序的数组[1,0,2,3,4,5,6,7,8,9]对改进前后的算法进行比较：

#include <iostream>
#include <vector>
#include <cstdlib>//rand(),srand
#include <ctime>//time()
#include "print_data.h"
#include "mysort.h"

using namespace std;
int main()
{
	srand((int)time(NULL));//随机种子
	vector<int> nums,nums1;
	print_data printTest;
	MySort sortTest;
	//for (int i = 0; i < 10; i++)
	//{
	//	nums.push_back(rand() % 100);//生成0-99之间的随机数
	//}
	nums.push_back(1);
	nums.push_back(0);
	nums.push_back(2);
	nums.push_back(3);
	nums.push_back(4);
	nums.push_back(5);
	nums.push_back(6);
	nums.push_back(7);
	nums.push_back(8);
	nums.push_back(9);
	nums1 = nums;
	printTest.printVector(nums);
	sortTest.BubbleSort(nums);
	printTest.printVector(nums);
	cout << endl;
	printTest.printVector(nums1);
	sortTest.BubbleSort1(nums1);
	printTest.printVector(nums1);
	system("pause");
	return 0;
}

结果

在这里插入图片描述

完整代码

mysort.h

#pragma once
#include <vector>
#include <iostream>
class MySort {
public:
	void BubbleSort(std::vector<int>& nums);//经典冒泡排序
	void BubbleSort1(std::vector<int>& nums);//改进冒泡排序
};

mysort.cpp

#include "mysort.h"
void MySort::BubbleSort(std::vector<int>& nums) {
	int count1 = 0, count2 = 0;
	int numsSize = nums.size();
	for (int i = 0; i < numsSize - 1; i++) {
		for (int j = 0; j < numsSize -1 - i; j++) {
			count1++;
			if (nums[j] > nums[j+1]){
				count2++;
				int tmp = nums[j];
				nums[j] = nums[j+1];
				nums[j+1] = tmp;
			}
		}
	}
	std::cout << "比较次数：" << count1 << " 交换次数：" << count2 << std::endl;
}

void MySort::BubbleSort1(std::vector<int>& nums) {
	int count1 = 0, count2 = 0;
	int numsSize = nums.size();
	bool flag = true;
	for (int i = 0; (i < numsSize - 1) && flag; i++) {
		flag = false;
		for (int j = 0; j < numsSize - 1 - i; j++) {
			count1++;
			if (nums[j] > nums[j + 1]) {
				count2++;
				flag = true;
				int tmp = nums[j];
				nums[j] = nums[j + 1];
				nums[j + 1] = tmp;
			}
		}
	}
	std::cout << "比较次数：" << count1 << " 交换次数：" << count2 << std::endl;
}

print_data.h

//#pragma once	两种方式防止重定义
#ifndef PRINT_DATA_H
#define PRINT_DATA_H
#include <iostream>
#include <vector>
class print_data
{
public:
	print_data() = default;
	~print_data() = default;
	void printHello();
	void printNum(int num);
	void printVector(std::vector<int> nums);
private:
};


#endif // !PRINT_DATA_H

print_data.cpp

#include "print_data.h"

void print_data::printHello() {
	std::cout << "print_data function!" << std::endl;
}
void print_data::printNum(int num){
	std::cout << num << std::endl;
}

void print_data::printVector(std::vector<int> nums) {
	int size = nums.size();
	for (int i = 0; i < size; i++)
	{
		std::cout << nums[i] << " ";
	}
	std::cout << std::endl;
}

main.cpp

#include <iostream>
#include <vector>
#include <cstdlib>//rand(),srand
#include <ctime>//time()
#include "print_data.h"
#include "mysort.h"

using namespace std;
int main()
{
	srand((int)time(NULL));//随机种子
	vector<int> nums,nums1;
	print_data printTest;
	MySort sortTest;
	//for (int i = 0; i < 10; i++)
	//{
	//	nums.push_back(rand() % 100);//生成0-99之间的随机数
	//}
	nums.push_back(1);
	nums.push_back(0);
	nums.push_back(2);
	nums.push_back(3);
	nums.push_back(4);
	nums.push_back(5);
	nums.push_back(6);
	nums.push_back(7);
	nums.push_back(8);
	nums.push_back(9);
	nums1 = nums;
	//经典冒泡排序
	printTest.printVector(nums);
	sortTest.BubbleSort(nums);
	printTest.printVector(nums);
	cout << endl;
	//改进冒泡排序
	printTest.printVector(nums1);
	sortTest.BubbleSort1(nums1);
	printTest.printVector(nums1);
	system("pause");
	return 0;
}

Surplus°

关注

0
点赞
踩
4

收藏

觉得还不错? 一键收藏
0
评论
常见排序算法之冒泡排序及其改进

目录冒泡排序算法思想时间复杂度经典冒泡排序代码测试结果冒泡排序算法的改进代码测试结果改进算法与经典算法的比较测试结果完整代码mysort.hmysort.cppprint_data.hprint_data.cppmain.cpp冒泡排序冒泡排序(BubbleSort)以其“在排序过程中相邻元素不断交换，一些元素慢慢被换到最后，看起来就像是元素在冒泡一样”而得名，是一种简单的基于关键词比较的排序算法。算法思想假设有n个数据，依次比较相邻两个元素，如果反序则交换位置，直到没有反序为止。以递增序为例，每
复制链接

扫一扫

专栏目录