冒泡排序

排序原理 当我们对一个数组进行冒泡排序的时候，我们可以把数组中的每个元素看做是一个一个的气泡，元素值较大的我们看成是重气泡，元素值较小的我们看成是轻气炮。根据生活常识我们知道，在水里，轻气炮肯定排在重气泡的前边，我们如何将轻重气泡按照我们知道的生活常识方式进行排序呢。这种这种排序的方式我们成冒泡排序。 所谓的冒泡排序就是对数组中的元素进行两两比较，如：第一次排序的第一步是我们对数组下标为0和1的两个元素进行比较，第二步为如果下标为0的元素比下标为1的元素大，我们就交换他们的位置，否则什么做，继续进行下一次排序，下一次排序为下标为1的元素与下标为2的元素进行比较，然后重复第一次排序的第二个步骤，以此往复，直到内层循环结束，最重的气泡已经排在了最后了。然后外层循环进行下一次循环，直到整个外循环结束，数组就已经排好序了。冒泡排序是就地排序，是稳定的。冒泡排序属于交换排序的一种。 时间复杂度 当数组为有序的，只需要一趟排序，元素之间的比较次数为n-1次，移动元素的次时为0次，此时时间复杂度为O(n)。 当数组为反序的，需要n-1趟排序，每趟排序元素之间比较次数为n-i此，比较次数达到了最大值n*(n-2)/2，别切没元素的移动需要三个步骤，移动次数也达到了最大值3*n(n-2)/2，所以当数组反序的时候冒泡排序的时间复杂第为O(n2)。 排序代码 package com.alg.sort;

冒泡排序 所谓冒泡，就是将元素两两之间进行比较，谁大就往后移动，直到将最大的元素排到最后面，接着再循环一趟，从头开始进行两两比较，而上一趟已经排好的那个元素就不用进行比较了。（图中排好序的元素标记为黄色柱子） 冒泡排序动图演示 上python代码： 1 def bubble_sort(items): 2 for i in range(len(items) - 1): 3 for j in range(len(items) - 1 - i): 4 if items[j] > items[j + 1]: 5 items[j], items[j + 1] = items[j + 1], items[j] 6 return items 7 8 9 list1 = [2,1,9,11,10,8,7] 10 print(bubble_sort(list1)) 输出结果： 1 [1, 2, 7, 8, 9, 10, 11] 这是冒泡排序最普通的写法，但你会发现它有一些不足之处，比如列表：[1,2,3,4,7,5,6]，第一次循环将最大的数排到最后，此时列表已经都排好序了，就是不用再进行第二次、第三次... 冒泡排序优化一： 设定一个变量为False，如果元素之间交换了位置，将变量重新赋值为True,最后再判断，在一次循环结束后，变量如果还是为False，则brak退出循环，结束排序。 1 def

摘要: 关于冒泡排序的思路和算法 所谓冒泡排序就是给定一组数，针对这组数进行的一种排序。具体的过程是，从第一个数开始，依次与后面的数进行比较，若 前一个数比后一个数大，则交换位置，再与第三个数进行比较，最后出现在结尾的就是本轮最大数字，再次重复直到排除顺序，这是选出最大来进行排列，也可以按选出最小来排，原理是一样的。 比如： 用第一个数依次与后面的数比较，比对方大，就交换位置，比对方小就不动，并放弃当前数字，用对方来与后面的数字继续比较，为的就是一次又一次的选出最大的数字。 　　比较过程大致： 1、比较相邻的元素。如果第一个比第二个大（小），就交换他们两个。 2、对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大（小）的数。 3、针对所有的元素重复以上的步骤，除了最后已经选出的元素（有序）。 4、持续每次对越来越少的元素（无序元素）重复上面的步骤，直到没有任何一对数字需要比较，则序列最终有序。 1 具体实现代码： 2 public static void main(args[]){ 3 for(int i=0;i<arr.length;i++){//外层循环控制轮数 4 for(int j=0;i<arr.length-1-i;j++){//内层循环控制比较次数 5 if(arr[j]>arr[j+1]){ 6 int temp=arr[j]

基本介绍 冒泡排序（Bubble Sorting）的基本思想是：通过对待 排序序列从前向后（从下标较小的元素开始）,依次比较 相邻元素的值，若发现逆序则交换，使值较大 的元素逐渐从前移向后部，就象水底下的气泡一样逐渐 向上冒。因为排序的过程中，各元素不断接近自己的位置，如果一趟比较下 来没有进行过交换，就说明序列有序，因此要在排序过程中设置 一个标志flag判断元素是否进行过交换。从而减少不必要的比较。 package com.diyo.sort; import java.text.SimpleDateFormat; import java.util.Arrays; import java.util.Date; /** * BubbleSort冒泡排序 时间复杂度O(n^2) * * @author DengZY * */ public class BubbleSort { public static void main(String[] args) { int arr[] = { 3, 9, -1, 10, -2 }; // 测试冒牌排序的速度O(n^2),给80000个数据测试 // int[] arr2 = new int[80000]; // for (int i = 0; i < 80000; i++) { // arr2[i] = (int) (Math.random(

　　相信凡是编程入门的都接触过冒泡排序算法，排序算法在编程中经常用到。 1. code 1 /** 2 * 冒泡排序 3 * 1、比较的轮数等于总数 - 1 4 * 2、比较次数等于要比较的个数 - 1 5 * --比较从第一个到最后一个 6 * --每一轮比较完得到一个最终值、不参与下一次比较 7 * 8 * */ 9 10 /** 11 * 最大时间复杂度 O(n^2) 12 * 空间复杂度 O(1) 13 * */ 14 var arr = [10, 0, 100, 20, 60, 30]; 15 var temp; 16 /** 17 * 从大到小 18 * **/ 19 /* 控制循环比较的轮数 */ 20 for (var i = 0; i < arr.length - 1; i++) { 21 /* 控制每一轮比较的次数 */ 22 for (var j = 0; j < arr.length - 1 - i; j++) { 23 if(arr[j] < arr[j + 1]){ 24 temp = arr[j]; 25 arr[j] = arr[j + 1]; 26 arr[j + 1] = temp; 27 } 28 } 29 } 30 // alert(arr); 31 console.log("从小到大 ：" + arr); 32 /** 33 * 从小到大

一、冒泡排序： 每一趟扫描交换，都记录是否存在逆序元素。 　　 举例如下： 　　 　　一旦经过某趟扫描之后，未发现任何逆序的相邻元素，即意味着排序任务已经完成，则通过返回标志“sorted”，以便算法即使终止。 　　改进的过程如下： 　　 　　跳过红色的部分，直接跳转到尾部。 　　 二、改进冒泡排序： 　　绿色代表无序，红色代表有序； 　反例：有序部分位于后面的部分，无序位于前面。每一躺扫描交换都是交换绿色的最后一个元素，使它就位。 用一种方法检测出这种状态，记录后面红色的部分是否是有序的。 　　 来源： https://www.cnblogs.com/ccpang/p/11415369.html

var arr = [5,99,2,9,1,5,67,7,10,23] //定义一个杂乱的数组 for(var i=0;i<arr.length-1;i++){ //大循环，用于遍历数组每个元素 for(var j=0;j<arr.length-i-1;j++){ //小循环，用于将数组中的某个元素与其它所有元素相比较 var sum; //声明一个局部变量，当作第三个空瓶子 if(arr[j]>arr[j+1]){ //判断当前元素和后一个元素的大小，如果当前元素比后一个元素大 sum = arr[j+1]; //将后一个元素（小元素）放在空瓶子里 arr[j+1] = arr[j]; //将当前元素（大元素）放在后一个元素的位置 arr[j] = sum; //将小元素从空瓶子中拿出来，放在当前元素的位置 } } } console.log(arr); //完成循环之后，初始数组的顺序已经发生改变 来源： https://www.cnblogs.com/CH-cnblogs/p/11410324.html

原理 重复比较相邻元素，择大者互换，从而完成排序 代码实现 @Test public void Bubblesort() { int[] data= {1, 4, 3, 2, 7, 6, 5, 8, 9, 0}; int position , scan,temp; for (position=data.length-1; position >=0 ; position--) { for (scan =0;scan<=position-1;scan++) { if (data[scan]>(data[scan+1])) { temp=data[scan]; data[scan]=data[scan+1]; data[scan+1]=temp; } } } for (int a:data) System.out.println(a); 性能分析 平均时间复杂度: O（n^2） 稳定的 优化方式参考: https://www.jianshu.com/p/f74fdcb2aa0c 来源： https://www.cnblogs.com/rainbowbridge/p/11410310.html

1. 冒泡排序： def bubble_sort ( list ) : for i in range ( 0 , len ( list ) ) : is_sorted = True for j in range ( 0 , len ( list ) - i - 1 ) : if list [ j ] > list [ j + 1 ] : list [ j ] , list [ j + 1 ] = list [ j + 1 ] , list [ j ] is_sorted = False if is_sorted : return list1 = [ 97 , 3 , 6 , 1 , 8 , 5 , - 20 , 100 , 50 , 200 , - 32 , 123 ] bubble_sort ( list1 ) print ( list1 ) 执行结果如下图： 2. 选择排序： def choose_sort ( list ) : list_len = len ( list ) for i in range ( 0 , list_len ) : for j in range ( i + 1 , list_len ) : if list [ i ] > list [ j ] : list [ i ] , list [ j ] = list [ j ] , list [ i ]

package com.itheima_01; public class ArrayDemo03 { public static void main(String[] args) { //定义一个数组 int[] arr = {24,69,80,78,13}; System.out.println("排序前为："+ArraytoString(arr)); bubblebinary(arr); System.out.println("排序后为："+ArraytoString(arr)); } //冒泡排序算法 public static void bubblebinary(int[] arr) { for(int x = 0;x<arr.length-1;x++) for (int i = 0; i < arr.length-1-x; i++) { if (arr[i] > arr[i + 1]) { int temp = arr[i]; arr[i] = arr[i + 1]; arr[i + 1] = temp; } } } //将数组中的元素按照指定的规则打印组成一个字符串:[元素1，元素2，。。。。] public static String ArraytoString(int[] arr) { StringBuilder sb = new StringBuilder();