冒泡排序

有趣的事，Python永远不会缺席！ 如需转发，请注明出处： 小婷儿的python https://www.cnblogs.com/xxtalhr/p/10786904.html 一、冒泡排序（Bubble Sort） 　　冒泡排序（Bubble Sort），是一种计算机科学领域的较简单的排序算法。它重复地走访过要排序的元素列，依次比较两个相邻的元素，一层一层的将较大的元素往后移动，其现象和气泡在上升过程中慢慢变大类似，故成为 冒泡排序 。 1、原理 从第一个和第二个开始比较，如果第一个比第二个大，则交换位置，然后比较第二个和第三个，逐渐往后 经过第一轮后最大的元素已经排在最后，所以重复上述操作的话第二大的则会排在倒数第二的位置。 那重复上述操作n-1次即可完成排序，因为最后一次只有一个元素所以不需要比较 2、举例 　　举个例子，假设我现在有一个数列需要使用冒泡来排序 [11, 99, 33 , 69, 77, 88, 55, 11, 33, 36,39, 66, 44, 22]，我们来看看使用冒泡的详细步骤： 首先11和99比较大小，99大，99继续和后面的作比较，直到最后一个元素，第一轮完了，列表是 [11, 33 , 69, 77, 88, 55, 11, 33, 36,39, 66, 44, 22, 99] 然后，重复第一轮操作，即第二轮比较列表是 [11, 33 , 69

　　冒泡排序是我们比较常用的一种排序算法，它的原理是：从头遍历未排好序的序列，每相邻的两个元素进行比较，较大（或较小）的元素放在后面，一轮遍历之后最大（或最小）的元素已经放到最后，然后依次重复之前的步骤把未排好序的序列进行排序，遍历 n-1 轮之后，整个序列就排好序了（第 n 轮不必要，因为第 n-1 轮排序后只剩下最后一个元素）。因为这种排序算法每次排好一个元素，就像冒泡一样，所以叫冒泡排序。 　　举个小例子： 　　　　arr[] = {6,1,5,3,2,4} 　　　　第一趟， 6 ,1,5,3,2,4 ： 1, 6 ,5,3,2,4 -> 1,5, 6 ,3,2,4 -> 1,5,3, 6 ,2,4 -> 1,5,3,2, 6 ,4 -> 1,5,3,2,4, 6 　　　　 第二趟， 1 ,5,3,2,4, 6 ： 1, 5 ,3,2,4, 6 -> 1,3, 5 ,2,4, 6 -> 1,3,2, 5 ,4, 6 -> 1,3,2,4, 5 , 6 　　　　第三趟， 1 ,3,2,4, 5 , 6 ： 1, 3 ,2,4, 5 , 6 -> 1,2, 3 ,4, 5 , 6 -> 1,2,3, 4 , 5 , 6 　　　　第四趟， 1 ,2,3, 4 , 5 , 6 ： 1, 2 ,3, 4 , 5 , 6 -> 1,2, 3 , 4 , 5 , 6 　　　　第五趟， 1

时间复杂度O（N 2 ） 进行n-1次每一次将一个最小的数（或最大的数）归位（最后一个数排好序），两两比较进行交换。 #include<bits/stdc++.h>#define me(x , y) memset(x , y , sizeof(x))#define SC scanf#define rep(i , j , n) for(int i = j ; i < n ; i ++)#define red(i , n , j) for(int i = n-1 ; i >= j ; i--)#define INF 0x3f3f3f3f#define mod 1000000007#define PI acos(-1)using namespace std;typedef long long ll ;int a[109];int n ;void bubble(){ rep(i , 1 , n){//n-1次操作 rep(j , 0 , n-i){//n-i次遍历 if(a[j]>a[j+1]){ swap(a[j] , a[j+1]); } } }}int main(){ cin >> n; rep(i , 0 , n){ SC("%d" , &a[i]); } bubble(); rep(i , 0 , n){ cout <<a[i]<<" "; } cout << endl;

一、思路 　　对一个序列中的元素，比较相邻的元素。如果第一个比第二个大，就交换它们两个，将大的元素放在右边，此时右边就称为有序区，左边就是无序区，不断重复的对左边区域相邻元素进行比较，右边有序区的元素不断增加，最后完成排序。 具体看下面的例子： 游标刚开始在第一个的位置，那么就会比较3和5的值，3没有5大，不换位置 游标移动到第二个的位置，比较5和2，5比2大，更换位置，如图右 游标移动到第三个位置，比较5和9，不换位置 这样循环一次叫做一趟（游标不移动到最后一个位置，也就是第四个位置），最后的结果就是选出最大的值在右侧，右侧也就是有序区，然后再进行第二趟、第三趟。 二、实现 ###range最右侧不取 def bubble_sort(l): for i in range(len(l)-1): #循环的是趟数 i表示趟数 for j in range(len(l)-i-1): #循环的是游标 j表示的是游标 if l[j]>l[j+1]: l[j+1],l[j]=l[j],l[j+1] #调换顺序 l=[3,5,2,9] bubble_sort(l) print(l) #[2, 3, 5, 9] 分析： 　　i和j都是从0开始取值，当进行第0趟时，j的取值是2，但是使用的range函数，所以右侧取不到，j的范围是（0,3），当进行第1趟时，j的返回是（0,2），一共可以进行

public static void main ( String [ ] args ) { //定义数组 int [ ] arr = { 10 , 2 , 15 , 7 } ; //控制排序轮数 for ( int i = 0 ; i < arr . length - 1 ; i ++ ) { //控制元素 和相邻元素相比较 for ( int j = 0 ; j < arr . length - 1 - i ; j ++ ) { //判断相邻的两个元素 if ( arr [ j ] > arr [ j + 1 ] ) { int temp = arr [ j ] ; arr [ j ] = arr [ j + 1 ] ; arr [ j + 1 ] = temp ; } } } //将数组变量转换成字符串常量 System . out . println ( Arrays . toString ( arr ) ) ; } 来源： CSDN 作者： LC_Struggle 链接： https://blog.csdn.net/LC_Struggle/article/details/104223275

冒泡排序（Bubble Sort）是啥？ 来源百度百科： 冒泡排序是一种简单的排序算法。它重复地走访过要排序的元素列，依次比较两个相邻的元素，如果他们的顺序（如从大到小、首字母从A到Z）错误就把他们交换过来。走访元素的工作是重复地进行直到没有相邻元素需要交换，也就是说该元素已经排序完成。 白话理解 1.首先交换，可以将数组的最大值移动到最后面。（从小到大） 2.在依次交换，最大值移动到，倒数第二位。 3.最后交换，直到所有数值排列整齐。 import java . util . Arrays ; public class Main { public static void main ( String [ ] args ) { int [ ] arr = new int [ ] { 2 , 6 , 3 , 7 , 0 , 9 } ; //定义一个一维数组 bubbleSort ( arr ) ; //调用方法 } public static void bubbleSort ( int [ ] arr ) { for ( int i = 1 ; i < arr . length ; i ++ ) { //每一轮循环 //它交换要比数组的最后一位小，-i就是当前的最后一位，-1才是最后一位的前一位。 for ( int j = 0 ; j < arr . length - i - 1 ;

排序算法 文章目录 排序算法 1.数据结构定义 2.冒泡排序 3.冒泡排序的改进 4.简单选择排序 5.直接插入排序 6.希尔排序（相当于直接插入排序的升级，先搞懂插入排序） 7.堆排序（相当于简单选择排序的升级） 8.归并排序 9.快速排序（冒泡排序的升级） 参考 1.数据结构定义 # define MAXSIZE 10000 /* 用于要排序数组个数最大值，可根据需要修改 */ typedef struct { int r [ MAXSIZE + 1 ] ; /* 用于存储要排序数组，r[0]用作哨兵或临时变量 */ int length ; /* 用于记录顺序表的长度 */ } SqList ; /* 交换L中数组r的下标为i和j的值 */ void swap ( SqList * L , int i , int j ) { int temp = L -> r [ i ] ; L -> r [ i ] = L -> r [ j ] ; L -> r [ j ] = temp ; } 2.冒泡排序 平均时间复杂度：O(n2) 从后往前依次比较相邻的两个数，如果后面的数比较小就交换位置，这样的话每循环一次就会有一个最小值被换到最前面了，然后再依次把其他的数冒上去。 go语言实现： // BubbleSort 冒泡排序 func BubbleSort ( array [ ] int

这次总结一下常用的一些排序用的算法，目前只是一部分，包括： 冒泡排序、桶排序、选择排序、插入排序、快速排序 （一）冒泡排序 冒泡排序是一种稳定的排序方法，因为如果两个相邻的数相同的话，将不会有所交换。 思路是比较两个相邻的数字，比较大的放在右边。 如果一共有n个数字，那么第一次则需要比较n-1次，然后比较的次数依次递减。 第一次比较，将最大的数放到了最后，第二次比较，将倒数第二个最大的数放到了倒数第二的位置，第三次比较将倒数第三最大的数放到了倒数第三的位置，以此类推，比较到最后得到的就是真正的顺序。 #include<bits/stdc++.h> using namespace std; int num[15]; int main() { int n; cin>>n; //输入所要排序的数字的个数 for(int i = 1;i<=n;i++){ cin>>num[i]; //输入需要排列的数字 } for(int i = n-1;i>=1;i--){ //进行冒泡排序操作 for(int j = 1;j<=i;j++){ if(num[j]>num[j+1]){ num[j] = num[j]^num[j+1]; num[j+1] = num[j]^num[j+1]; num[j] = num[j]^num[j+1]; } } } for(int i = 1;i<=n;i++){

冒泡排序 冒泡排序是一种简单的排序算法。它重复地遍历要排序的数列，一次比较两个元素，如果他们的顺序错误就把它们交换过来。遍历数列的工作是重复的进行直到没有在需要的交换，也就是说该数列已经排序完成，这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。 冒泡算法的运作如下： 比较相邻的元素，如果第一个元素大于第二个元素（升序），就交换它们两个。 对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对，这步完成后，最后的元素会是最大的数。 针对所有的元素重复以上的步骤，除了最后一个 持续每次越来越少的元素重复上面的步骤，直到没有任何一堆数字需要比较。 冒泡算法分析 交换过程图示（ 第一次 ）： 那么我们需要进行n-1次冒泡过程，每次对应的比较次数如下图所示： Pass Comparisons 1 n-1 2 n-2 3 n-3 … … n-1 1 代码实现 def bubble_sort(alist): """冒泡排序""" for j in range(len(alist)-1): for i in range(len(alist)-j-1): if alist[i] > alist[i+1]: alist[i], alist[i+1] = alist[i+1], alist[i] return alist 时间复杂度 最优时间复杂度：O(n

#冒泡排序#基本思想：两两相邻记录的关键字，如果反序则交换，直到没有反序的记录为止#要点：1.两两注意是相邻的两个元素的意思# 2.如果有n个元素需要比较n-1次，每一轮减少1次比较# 3.既然叫冒泡排序，那就是从下往上两两比较，所以看上去就跟泡泡往上冒一样。def bubblesort(numList): leng = len(numList)-1 for i in range(leng): #i=0 for j in range(leng-i):#j=0,1,2,3,4,5,6 if numList[leng-j] < numList[leng-j-1]:#leng-j=6,leng-j-1=5 midnum = numList[leng-j] numList[leng-j] = numList[leng-j-1] numList[leng-j-1] = midnum print(numList) return numListprint(bubblesort([1,2,-1,8,6,7,-2]))# [-2, 1, 2, -1, 8, 6, 7] 从后往前，把最小的数排到前面，将-2冒泡到最前# [-2, -1, 1, 2, 6, 8, 7]# [-2, -1, 1, 2, 6, 7, 8]# [-2, -1, 1, 2, 6, 7, 8]# [-2, -1, 1, 2, 6,