冒泡排序

经典排序算法 - 冒泡排序Bubble sort 原理是临近的数字两两进行比较,按照从小到大或者从大到小的顺序进行交换, 这样一趟过去后,最大或最小的数字被交换到了最后一位, 然后再从头开始进行两两比较交换,直到倒数第二位时结束,其余类似看例子 例子为从小到大排序, 原始待排序数组 | 6 | 2 | 4 | 1 | 5 | 9 | 第一趟排序(外循环) 第一次两两比较6 > 2交换(内循环) 交换前状态 | 6 | 2 | 4 | 1 | 5 | 9 | 交换后状态 | 2 | 6 | 4 | 1 | 5 | 9 | 第二次两两比较,6 > 4交换 交换前状态| 2 | 6 | 4 | 1 | 5 | 9 | 交换后状态| 2 | 4 | 6 | 1 | 5 | 9 | 第三次两两比较,6 > 1交换 交换前状态| 2 | 4 | 6 | 1 | 5 | 9 | 交换后状态| 2 | 4 | 1 | 6 | 5 | 9 | 第四次两两比较,6 > 5交换 交换前状态| 2 | 4 | 1 | 6 | 5 | 9 | 交换后状态| 2 | 4 | 1 | 5 | 6 | 9 | 第五次两两比较,6 < 9不交换 交换前状态| 2 | 4 | 1 | 5 | 6 | 9 | 交换后状态| 2 | 4 | 1 | 5 | 6 | 9 | 第二趟排序(外循环) 第一次两两比较2 <

来源： CSDN 作者： でこもり さなえ 链接： https://blog.csdn.net/weixin_44077863/article/details/103628529

排序算法可以分为内部排序和外部排序，内部排序是数据记录在内存中进行排序，而外部排序是因排序的数据很大，一次不能容纳全部的排序记录，在排序过程中需要访问外存。常见的内部排序算法有：插入排序、希尔排序、选择排序、冒泡排序、归并排序、快速排序、堆排序、基数排序等。用一张图概括 关于时间复杂度： 平方阶 (O(n2)) 排序 各类简单排序：直接插入、直接选择和冒泡排序。 线性对数阶 (O(nlog2n)) 排序 快速排序、堆排序和归并排序。 O(n1+§)) 排序，§ 是介于 0 和 1 之间的常数。 希尔排序。 线性阶 (O(n)) 排序 基数排序，此外还有桶、箱排序。 关于稳定性： 稳定的排序算法：冒泡排序、插入排序、归并排序和基数排序。 不是稳定的排序算法：选择排序、快速排序、希尔排序、堆排序。 名词解释： n：数据规模 k：“桶”的个数 In-place：占用常数内存，不占用额外内存 Out-place：占用额外内存 稳定性：排序后 2 个相等键值的顺序和排序之前它们的顺序相同 冒泡排序 冒泡排序（Bubble Sort）也是一种简单直观的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。

思路： 俩俩交换，大的放在后面，第一次排序后最大值已在数组末尾。 因为俩俩交换，需要n-1趟排序，比如10个数，需要9趟排序 代码实现要点： 两个for循环，外层循环控制排序的趟数，内层循环控制比较的次数 每趟过后，比较的次数都应该要减1 优化：如果一趟排序后也没有交换位置，那么该数组已有序～ //外层循环是排序的趟数 for (int i = 0; i < arrays.length -1 ; i++) { //每比较一趟就重新初始化为0 isChange = 0; //内层循环是当前趟数需要比较的次数 for (int j = 0; j < arrays.length - i - 1; j++) { //前一位与后一位与前一位比较，如果前一位比后一位要大，那么交换 if (arrays[j] > arrays[j + 1]) { temp = arrays[j]; arrays[j] = arrays[j + 1]; arrays[j + 1] = temp; //如果进到这里面了，说明发生置换了 isChange = 1; } } //如果比较完一趟没有发生置换，那么说明已经排好序了，不需要再执行下去了 if (isChange == 0) { break; } } 来源： CSDN 作者： M&Y 链接： https://blog.csdn.net/qq_37883866

冒泡排序 冒泡排序就是把小的元素往前调或者把大的元素往后调。比较是相邻的两个元素比较，交换也发生在这两个元素之间。所以，如果两个元素相等，我想你是不会再无聊地把他们俩交换一下的；如果两个相等的元素没有相邻，那么即使通过前面的两两交换把两个相邻起来，这时候也不会交换，所以相同元素的前后顺序并没有改变，所以冒泡排序是一种稳定排序算法。 /** * 冒泡法，小的在前面 * @param array $arr * @return array */ function bubbleSort($arr){ $num = count($arr); if( $num<=1 ){ return $arr; } for($i=0;$i<$num;$i++){ for ($j=$num-1;$j>$i;$j--){ if( $arr[$j]<$arr[$i] ){ $t = $arr[$j]; $arr[$j] = $arr[$i]; $arr[$i] = $t; } } } return $arr; } 　　 选择排序 选择排序是给每个位置选择当前元素最小的，比如给第一个位置选择最小的，在剩余元素里面给第二个元素选择第二小的，依次类推，直到第n-1个元素，第n个元素不用选择了，因为只剩下它一个最大的元素了。那么，在一趟选择，如果当前元素比一个元素小，而该小的元素又出现在一个和当前元素相等的元素后面

冒泡排序的英文Bubble Sort，是一种最基础的交换排序。 　　大家一定都喝过汽水，汽水中常常有许多小小的气泡，哗啦哗啦飘到上面来。这是因为组成小气泡的二氧化碳比水要轻，所以小气泡可以一点一点向上浮动。而我们的冒泡排序之所以叫做冒泡排序，正是因为这种排序算法的每一个元素都可以像小气泡一样，根据自身大小，一点一点向着数组的一侧移动。 冒泡排序算法的原理如下： 比较相邻的元素。如果第一个比第二个大，就交换他们两个。 对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。 针对所有的元素重复以上的步骤，除了最后一个。 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。 具体如何来移动呢？让我们来看一个栗子： 有8个数组成一个无序数列：5，8，6，3，9，2，1，7，希望从小到大排序。按照冒泡排序的思想，我们要把相邻的元素两两比较，根据大小来交换元素的位置，过程如下： 首先让5和8比较，发现5比8要小，因此元素位置不变。 接下来让8和6比较，发现8比6要大，所以8和6交换位置。 继续让8和3比较，发现8比3要大，所以8和3交换位置。 继续让8和9比较，发现8比9要小，所以元素位置不变。 接下来让9和2比较，发现9比2要大，所以9和2交换位置。 接下来让9和1比较，发现9比1要大，所以9和1交换位置。 最后让9和7比较

package algorithm; import java.util.Arrays; public class Bubble { public static void main(String[] args) { int[] aa=new int[] {1,5,4,3,10}; System.out.println(Arrays.toString(sort(aa))); } public static int[] sort(int[] old) { int count =0; int i = old.length; boolean change; do { change = false; for (int j = 1; j < i; j++) { count++; if (old[j] < old[j - 1]) { int temp = old[j]; old[j] =old[j-1]; old[j-1] =temp; change =true; } } i--; } while (i > 1 && i < old.length && change); System.out.println(count); return old; } } 这种冒泡排序的算法时间复杂度 O(n) = T(f(n)) 来源： CSDN 作者： daxian_am461 链接： https://blog

一.冒泡排序简介 比较相邻的元素。如果第一个比第二个大，就交换他们两个。 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。 针对所有的元素重复以上的步骤，除了最后一个。 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。 动态图： 二.代码案例 package day0515; public class demo_sort { public static void main(String[] args) { //冒泡排序算法 int[] numbers=new int[]{1,5,8,2,3,9,4}; int i,j; for(i=0;i<numbers.length-1;i++) { for(j=0;j<numbers.length-1-i;j++) { if(numbers[j]>numbers[j+1]) { int temp=numbers[j]; numbers[j]=numbers[j+1]; numbers[j+1]=temp; } } } System.out.println("从小到大排序后的结果是:"); for(i=0;i<numbers.length;i++) System.out.print(numbers[i]+" "); } } 三.debug命令调试 在需要断点的行数前面进行点击

package com.liuxian.algo; public class MySortClass implements Comparable<MySortClass> { public String userName; public int num; public MySortClass(String userName, int num) { this.userName = userName; this.num = num; } public int compareTo(MySortClass o) { return this.num - o.num; } } package com.liuxian.algo; public class Helper { public static void printArray(MySortClass [] sorts) { for (int i = 0; i < sorts.length; i++) { System.out.println(sorts[i].num); } } } package com.liuxian.algo; import java.util.Random; public class BubbleSort { public static <AnyType extends Comparable<? super

冒泡排序 算法思想 反复扫描待排序记录的序列，在扫描的过程中顺次比较相邻的两个元素大小，若如需就交换位置。 /* * To change this license header, choose License Headers in Project Properties. * To change this template file, choose Tools | Templates * and open the template in the editor. */ package paixu ; public class PaiXu { public static void main ( String [ ] args ) { int [ ] a = { 48 , 62 , 35 , 77 , 55 , 14 , 35 , 98 } ; Bubblesort ( a , a . length ) ; for ( int i = 0 ; i < a . length ; i ++ ) { System . out . println ( a [ i ] ) ; } } public static void Bubblesort ( int [ ] a , int n ) { for ( int i = 0 ; i < n - 1 ; i ++ ) { for ( int j = 0