冒泡排序及冒泡排序的优化-＞鸡尾酒排序

2023-10-28 16:10
文章标签 优化 排序 冒泡排序 鸡尾酒

本文主要是介绍冒泡排序及冒泡排序的优化-＞鸡尾酒排序，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

什么是冒泡排序

冒泡排序的英文Bubble Sort，是一种最基础的交换排序。
大家一定都喝过汽水，汽水中常常有许多小小的气泡，哗啦哗啦飘到上面来。这是因为组成小气泡的二氧化碳比水要轻，所以小气泡可以一点一点向上浮动。
冒泡排序（Bubble Sorting）的基本思想是：通过对待排序序列从前向后（从下标较小的元素开始）,依次比较 相邻元素的值，若发现逆序则交换，使值较大的元素逐渐从前移向后部，就象水底下的气泡一样逐渐向上冒。

演示冒泡过程的例子(图解)

在这里插入图片描述

小结上面的图解过程:
(1) 一共进行 数组的大小-1 次大的循环
(2)每一趟排序的次数在逐渐的减少
(3) 如果我们发现在某趟排序中，没有发生一次交换， 可以提前结束冒泡排序。这个就是优化

冒泡排序第一版

#include <iostream>
#include <string>
using namespace std;
/*数组遍历*/
void ListShow(int list[], int length){for (int i = 0; i < length; i++){cout << list[i] << "  ";}cout << endl;
}
/*==================冒泡排序==========================*/
void BubbleSort(int *list, int length)
{int temp; //定义中间变量cout << "====冒泡排序=====" << endl;for (int i = 0; i < length - 1; i++){ //数组长度为n，冒泡排序比较n-1趟//每趟中，数据两两比较，大的往后移for (int j = 0; j < length - i - 1; j++){if (list[j] > list[j + 1]){ //交换,从小往大,若>从大往小temp = list[j];list[j] = list[j + 1];list[j + 1] = temp;}}cout << "第" << i + 1 << "趟: ";ListShow(list, length);}
}
int main()
{int list[9] = {9, 3, 1, 4, 2, 7, 8, 6, 5};int length = sizeof(list) / sizeof(list[0]); //求数组的长度，C++固定方式cout << "排序前" << endl;ListShow(list, length);BubbleSort(list, length);cout << "排序后" << endl;ListShow(list, length);return 0;
}

冒泡排序第二版

这一版代码做了小小的改动，利用布尔变量flag作为标记。如果在本轮排序中，元素有交换，则说明数列无序；如果没有元素交换，说明数列已然有序，直接跳出大循环。

#include <iostream> //冒泡优化第二版，解决整体有序还在排问题
#include <string>
using namespace std;
void listshow(int list[], int length)
{for (int i = 0; i < length; i++){cout << list[i] << "  ";}cout << endl;
}
void bubblesort(int array[], int length)
{int temp;for (int i = 0; i < length - 1; i++){bool flage = true;for (int j = 0; j < length - i - 1; j++){if (array[j] > array[j + 1]){temp = array[j];array[j] = array[j + 1];array[j + 1] = temp;flage = false;}}if (flage){break;}else{cout << "第" << i + 1 << "次" << endl;listshow(array, length);}}
}int main()
{int a[7] = {3, 4, 1, 5, 6, 7, 8};int b = sizeof(a) / sizeof(a[0]);cout << "排序前" << endl;listshow(a, b);bubblesort(a, b);cout << "排序后" << endl;listshow(a, b);
}

冒泡排序第三版

为了说明这个问题，我们重新选择一个新的数列：
3 4 2 1 5 6 7 8
这个数列的特点是前半部分（3，4，2，1）无序，后半部分（5，6，7，8）升序，并且后半部分
的元素已经是数列最大值。
让我们按照冒泡排序的思路来进行排序，看一看具体效果：
第一轮
元素3和4比较，发现3小于4，所以位置不变。
元素4和2比较，发现4大于2，所以4和2交换。
元素4和1比较，发现4大于1，所以4和1交换。
元素4和5比较，发现4小于5，所以位置不变。
元素5和6比较，发现5小于6，所以位置不变。
元素6和7比较，发现6小于7，所以位置不变。
元素6和7比较，发现6小于7，所以位置不变。
第一轮结束，数列有序区包含一个元素：3 2 1 4 5 6 7 8
第二轮
元素3和2比较，发现3大于2，所以3和2交换。
元素3和4比较，发现3小于4，所以位置不变。
元素4和5比较，发现4小于5，所以位置不变。
元素5和6比较，发现5小于6，所以位置不变。
元素6和7比较，发现6小于7，所以位置不变。
元素7和8比较，发现7小于8，所以位置不变。
第二轮结束，数列有序区包含一个元素：2 1 3 4 5 6 7 8

这个问题的关键点在哪里呢？关键在于对数列有序区的界定。
按照现有的逻辑，有序区的长度和排序的轮数是相等的。比如第一轮排序过后的有序区长度是1，第二轮排序过后的有序区长度是2 …
实际上，数列真正的有序区可能会大于这个长度，比如例子中仅仅第二轮，后面5个元素实际都已经属于有序区。因此后面的许多次元素比较是没有意义的。
如何避免这种情况呢？我们可以在每一轮排序的最后，记录下最后一次元素交换的位置，那个位置也就是无序数列的边界，再往后就是有序区了。

#include <iostream> //冒泡优化第三版,后面部分已经有序
#include <string>
using namespace std;
void ListShow(int list[], int length)
{for (int i = 0; i < length; i++){cout << list[i] << "  ";}cout << endl;
}
void BubbleSort(int array[], int length)
{int t;int lastchange = 0; //记录最后一次交换的位置for (int i = 0; i < length - 1; i++){bool flage = true;				//有序标记，每一轮的初始是trueint sortbuder = length - i - 1; //无序数列的边界，每次比较只需要比到这里为止for (int j = 0; j < sortbuder; j++){if (array[j] > array[j + 1]){t = array[j];array[j] = array[j + 1];array[j + 1] = t;flage = false;		//有元素交换，所以不是有序，标记变为falselastchange = j + 1; //把无序数列的边界更新为最后一次交换元素的位置}}if (flage){break;}else{cout << "第" << i + 1 << "次" << endl;sortbuder = lastchange;ListShow(array, length);}}
}
int main()
{int a[] = {1, 44, 4, 5, 64, 34, 35, 36, 39};int b = sizeof(a) / sizeof(a[0]);cout<<"排序前"<<endl;ListShow(a, b);BubbleSort(a, b);cout<<"排序后"<<endl;ListShow(a, b);
}

这一版代码中，sortBorder就是无序数列的边界。每一轮排序过程中，sortBorder之后的元素就完全不需要比较了，肯定是有序的。

冒泡排序第四版（鸡尾酒排序）

鸡尾酒排序的元素比较和交换过程是双向的。
让我们来举一个栗子：
在这里插入图片描述
有8个数组成一个无序数列：2，3，4，5，6，7，8，1，希望从小到大排序
如果按照冒泡排序的思想，排序的过程是什么样呢？
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

可以看到从2到8已经是有序的了，只有1元素的位置不对，缺还要进行7轮排序，这也太憋屈了吧？
鸡尾酒排序正是解决这种问题

鸡尾酒的详细过程

第一轮（和冒泡排序一样，8和1交换）
在这里插入图片描述
第二轮
此时开始不一样了，我们反过来从右往左比较和交换：
8已经处于有序区，我们忽略掉8，让1和7比较。元素1小于7，所以1和7交换位置：
在这里插入图片描述
接下来1和6比较，元素1小于6，所以1和6交换位置
在这里插入图片描述
接下来1和5比较，元素1小于5，所以1和5交换位置：
在这里插入图片描述
接下来1和4交换，1和3交换，1和2交换，最终成为了下面的结果：
在这里插入图片描述
第三轮（虽然已经有序，但是流程并没有结束）
鸡尾酒排序的第三轮，需要重新从左向右比较和交换：
1和2比较，位置不变；2和3比较，位置不变；3和4比较，位置不变…6和7比较，位置不变。
没有元素位置交换，证明已经有序，排序结束。

这就是鸡尾酒排序的思路。排序过程就像钟摆一样，第一轮从左到右，第二轮从右到左，第三轮再从左到右…

#include <iostream> //鸡尾酒排序,先从左向右，后从右向左
#include <string>
using namespace std;
void ListShow(int list[], int length)
{for (int i = 0; i < length; i++){cout << list[i] << "  ";}cout << endl;
}
void BubbleSort(int array[], int length)
{int t;for (int i = 0; i < length / 2; i++) //因为左右排序所以只需进行一半排序就可以了{cout << "第" << i + 1 << "趟" << endl;//奇数轮，从左向右比较和交换bool flage = true;for (int j = 0; j < length - i - 1; j++){if (array[j] > array[j + 1]){t = array[j];array[j] = array[j + 1];array[j + 1] = t;flage = false;}}if (flage){break;}else{cout << "从左到右第" << i + 1 << "次" << endl;ListShow(array, length);}//偶数轮之前，重新标记为trueflage = true;//偶数轮，从右向左比较和交换for (int j = length - i - 1; j > i; j--){if (array[j] < array[j - 1]){t = array[j];array[j] = array[j - 1];array[j - 1] = t;flage = false;}}if (flage){break;}else{cout << "从右到左第" << i + 1 << "次" << endl;ListShow(array, length);}}
}
int main()
{int a[] = {2, 3, 4, 5, 6, 7, 1, 8};int b = sizeof(a) / sizeof(a[0]);cout << "排序前" << endl;ListShow(a, b);BubbleSort(a, b);cout << "排序后" << endl;ListShow(a, b);
}

这段代码是鸡尾酒排序的原始实现。代码外层的大循环控制着所有排序回合，大循环内包含两个小循环，第一个循环从左向右比较并交换元素，第二个循环从右向左比较并交换元素。

冒泡排序第五版

鸡尾酒排序的优化

对于单向的冒泡排序，我们需要设置一个边界值，对于双向的鸡尾酒排序，我们需要设置两个边界值。请看代码：

#include <iostream> //鸡尾酒排序优化,先从左向右，后从右向左,优化
using namespace std;
void ListShow(int list[], int length)
{for (int i = 0; i < length; i++){cout << list[i] << "  ";}cout << endl;
}
void BubbleSort(int array[], int length)
{int LastRightExchange = 0; //记录右侧最后一次交换的位置int LastLeftExchange = 0;  //记录左侧最后一次交换的位置int LeftSortBorder = 0;	   //无序数列的左边界，每次比较只需要比到这里为止int RightSortBorder;	   //无序数列的右边界，每次比较只需要比到这里为止int t;for (int i = 0; i < length / 2; i++) //因为左右排序所以只需进行一半排序就可以了{cout << "第" << i + 1 << "趟" << endl;bool flage = true; //有序标记，每一轮的初始是trueRightSortBorder = length - i - 1;//奇数轮，从左向右比较和交换for (int j = LeftSortBorder; j < RightSortBorder; j++){if (array[j] > array[j + 1]){t = array[j];array[j] = array[j + 1];array[j + 1] = t;flage = false;LastRightExchange = j + 1;}}RightSortBorder = LastRightExchange;if (flage){break;}else{cout << "从左到右第" << i + 1 << "次" << endl;ListShow(array, length);}//偶数轮之前，重新标记为trueflage = true;//偶数轮，从右向左比较和交换for (int j = RightSortBorder; j > LeftSortBorder; j--){if (array[j] < array[j - 1]){t = array[j];array[j] = array[j - 1];array[j - 1] = t;flage = false;LastLeftExchange = j - 1;}}LeftSortBorder = LastLeftExchange;if (flage){break;}else{cout << "从右到左第" << i + 1 << "次" << endl;ListShow(array, length);}}
}
int main()
{int a[] = {2, 3, 4, 5, 6, 7, 1, 8};int b = sizeof(a) / sizeof(a[0]);cout << "排序前" << endl;ListShow(a, b);BubbleSort(a, b);cout << "排序后" << endl;ListShow(a, b);
}

这篇关于冒泡排序及冒泡排序的优化-＞鸡尾酒排序的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/294371。

相关文章

Java List排序实例代码详解

Java List排序实例代码详解

《JavaList排序实例代码详解》：本文主要介绍JavaList排序的相关资料,Java排序方法包括自然排序、自定义排序、Lambda简化及多条件排序,实现灵活且代码简洁,文中通过代码介绍的... 目录一、自然排序二、自定义排序规则三、使用 Lambda 表达式简化 Comparator四、多条件排序五、
阅读更多...
JAVA数组中五种常见排序方法整理汇总

JAVA数组中五种常见排序方法整理汇总

《JAVA数组中五种常见排序方法整理汇总》本文给大家分享五种常用的Java数组排序方法整理,每种方法结合示例代码给大家介绍的非常详细,感兴趣的朋友跟随小编一起看看吧... 目录前言：法一：Arrays.sort()法二：冒泡排序法三：选择排序法四：反转排序法五：直接插入排序前言：几种常用的Java数组排序
阅读更多...
SpringBoot中HTTP连接池的配置与优化

SpringBoot中HTTP连接池的配置与优化

《SpringBoot中HTTP连接池的配置与优化》这篇文章主要为大家详细介绍了SpringBoot中HTTP连接池的配置与优化的相关知识,文中的示例代码讲解详细,感兴趣的小伙伴可以跟随小编一起学习一... 目录一、HTTP连接池的核心价值二、Spring Boot集成方案方案1：Apache HttpCl
阅读更多...
PyTorch高级特性与性能优化方式

PyTorch高级特性与性能优化方式

《PyTorch高级特性与性能优化方式》：本文主要介绍PyTorch高级特性与性能优化方式,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教... 目录一、自动化机制1.自动微分机制2.动态计算图二、性能优化1.内存管理2.GPU加速3.多GPU训练三、分布式训练1.分布式数据
阅读更多...
MySQL中like模糊查询的优化方案

MySQL中like模糊查询的优化方案

《MySQL中like模糊查询的优化方案》在MySQL中,like模糊查询是一种常用的查询方式,但在某些情况下可能会导致性能问题,本文将介绍八种优化MySQL中like模糊查询的方法,需要的朋友可以参... 目录1. 避免以通配符开头的查询2. 使用全文索引（Full-text Index）3. 使用前缀索
阅读更多...
C#实现高性能Excel百万数据导出优化实战指南

C#实现高性能Excel百万数据导出优化实战指南

《C#实现高性能Excel百万数据导出优化实战指南》在日常工作中,Excel数据导出是一个常见的需求,然而,当数据量较大时,性能和内存问题往往会成为限制导出效率的瓶颈,下面我们看看C#如何结合EPPl... 目录一、技术方案核心对比二、各方案选型建议三、性能对比数据四、核心代码实现1. MiniExcel
阅读更多...
MySQL索引的优化之LIKE模糊查询功能实现

MySQL索引的优化之LIKE模糊查询功能实现

《MySQL索引的优化之LIKE模糊查询功能实现》：本文主要介绍MySQL索引的优化之LIKE模糊查询功能实现,本文通过示例代码给大家介绍的非常详细,感兴趣的朋友一起看看吧... 目录一、前缀匹配优化二、后缀匹配优化三、中间匹配优化四、覆盖索引优化五、减少查询范围六、避免通配符开头七、使用外部搜索引擎八、分
阅读更多...
Python通过模块化开发优化代码的技巧分享

Python通过模块化开发优化代码的技巧分享

《Python通过模块化开发优化代码的技巧分享》模块化开发就是把代码拆成一个个“零件”,该封装封装,该拆分拆分,下面小编就来和大家简单聊聊python如何用模块化开发进行代码优化吧... 目录什么是模块化开发如何拆分代码改进版：拆分成模块让模块更强大：使用 __init__.py你一定会遇到的问题模www.
阅读更多...
Mybatis 传参与排序模糊查询功能实现

Mybatis 传参与排序模糊查询功能实现

《Mybatis传参与排序模糊查询功能实现》：本文主要介绍Mybatis传参与排序模糊查询功能实现,本文通过实例代码给大家介绍的非常详细,感兴趣的朋友跟随小编一起看看吧... 目录一、#{ }和${ }传参的区别二、排序三、like查询四、数据库连接池五、mysql 开发企业规范一、#{ }和${ }传参的
阅读更多...
SpringBoot首笔交易慢问题排查与优化方案

SpringBoot首笔交易慢问题排查与优化方案

《SpringBoot首笔交易慢问题排查与优化方案》在我们的微服务项目中,遇到这样的问题：应用启动后,第一笔交易响应耗时高达4、5秒,而后续请求均能在毫秒级完成,这不仅触发监控告警,也极大影响了用户体... 目录问题背景排查步骤1. 日志分析2. 性能工具定位优化方案：提前预热各种资源1. Flowable
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2