冒泡排序

百科名片

冒泡排序（Bubble Sort），是一种 计算机科学领域的较简单的 排序算法。

它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。

这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端，故名。

由于冒泡排序简洁的特点，它通常被用来对于计算机程序设计入门的学生介绍算法的概念。

目录

算法原理

算法分析

算法描述

展开

算法原理

算法分析

算法描述

展开

编辑本段算法原理

冒泡排序算法的运作如下：

1. 比较相邻的元素。如果第一个比第二个大，就交换他们两个。
2. 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
3. 针对所有的元素重复以上的步骤，除了最后一个。
4. 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。 ^[1]

编辑本段算法分析

时间复杂度

　　若文件的初始状态是正序的，一趟扫描即可完成排序。所需的关键字比较次数

和记录移动次数

均达到最小值：

，

。

所以，冒泡排序最好的时间复杂度为

。
　　若初始文件是反序的，需要进行

趟排序。每趟排序要进行

次关键字的比较(1≤i≤n-1)，且每次比较都必须移动记录三次来达到交换记录位置。在这种情况下，比较和移动次数均达到最大值：

冒泡排序的最坏时间复杂度为

。

综上，因此冒泡排序总的平均时间复杂度为

。

算法稳定性

冒泡排序就是把小的元素往前调或者把大的元素往后调。比较是相邻的两个元素比较，交换也发生在这两个元素之间。所以，如果两个元素相等，我想你是不会再无聊地把他们俩交换一下的；如果两个相等的元素没有相邻，那么即使通过前面的两两交换把两个相邻起来，这时候也不会交换，所以相同元素的前后顺序并没有改变，所以冒泡排序是一种稳定排序算法。

编辑本段算法描述

易语言

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

数组 = { 233, 1, 5, 5, 6, 8, 7, 9, 41, 62, 2, 1, 3, 0 } c = 1 b = 取数组成员数 (数组) .判断循环首 (c > 0)     c = 0     .变量循环首 (1, b － 1, 1, d)          .如果真 (数组 [d] > 数组 [d + 1])  ' 此处用于，对两个数据进行对比，可以修改成，拼音，数字大小，文本长度，等等              e = 数组 [d]              数组 [d] = 数组 [d + 1]              数组 [d + 1] = e              b = d              c = c + 1          .如果真结束       .变量循环尾 () .判断循环尾 ()

C语言

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33

# include <stdio.h>   void bubbleSort( int arr[], int n) {     int i,j,t;       for (i=0;i<n-1;i++)          for (j=0;j<n-i-1;j++)              if (arr[j+1]<arr[j])              {                t=arr[j+1];                arr[j+1]=arr[j];                arr[j]=t;              } }   void print( int arr[], int n)    //打印数组 {     int i=0;     for (;i<n;i++)     {          printf ( "%d  " ,arr[i]);     }     printf ( "\n" ); } int main( void ) {     int arr[]={49,15,52,64,98};    //测试数据     print(arr,5);     bubbleSort(arr,5);          printf ( "排序后的结果：\n" );     print(arr,5);     return 0; }

^[1]

JAVA

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

public class BubbleSort{     public void sort( int [] a) {          int temp = 0 ;          for ( int i = a.length - 1 ; i > 0 ; --i) {              boolean isSort= false ;              for ( int j = 0 ; j < i; ++j) {                 if (a[j + 1 ] < a[j]) {                      temp = a[j];                      a[j] = a[j + 1 ];                      a[j + 1 ] = temp;                      isSort= true ;                 }              }              if (!isSort) break ;          }     } }

^[2]

PHP

1 2 3 4 5 6 7 8 9 10 11 12 13 14

$a = array ( '3' , '8' , '1' , '4' , '11' , '7' ); print_r( $a ); $len = count ( $a ); //从小到大 for ( $i =1; $i < $len ; $i ++) {     for ( $j = $len -1; $j >= $i ; $j --)          if ( $a [ $j ]< $a [ $j -1])          { //如果是从大到小的话，只要在这里的判断改成if($b[$j]>$b[$j-1])就可以了              $x = $a [ $j ];              $a [ $j ]= $a [ $j -1];              $a [ $j -1]= $x ;           } }

^[3]

Perl

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

#! /usr/bin/perl -w   use strict;   my @list = qw / 3 5 6 2 12/; bubble_sort(\ @list , scalar @list ); print "@list\n" ;   sub bubble_sort {     my $arrays_ref = shift ;     my $num = shift ;       for ( my $i = 0; $i < $num - 1; $i ++) {          for ( my $j = 0; $j < $num - $i - 1; $j ++) {              if ( $arrays_ref ->[ $j ] > $arrays_ref ->[ $j -1]) {                 my $tmp = $arrays_ref ->[ $j ];                 $arrays_ref ->[ $j ] = $arrays_ref ->[ $j -1];                 $arrays_ref ->[ $j -1] = $tmp ;              }          }     }     return $arrays_ref ; }

^[4]

Objective-C

1 2 3 4 5 6 7 8 9 10 11 12 13 14

- ( void )bubbleSort:(NSMutableArray *)array {     int i, y;     BOOL bFinish = YES;     for (i = 1; i<= [array count] && bFinish; i++) {          bFinish = NO;          for (y = ( int )[array count]-1; y>=i; y--) {              if ([[array objectAtIndex:y] intValue] < [[array objectAtIndex:y-1] intValue]) {                 [array exchangeObjectAtIndex:y-1 withObjectAtIndex:y];                 bFinish = YES;              }          }     } }

Python

1 2 3 4 5 6 7 8 9 10 11 12

alist = [ 1 , 12 , 2 , 4 , 51 , 66 , 45 , 25 , 96 , 78 , 55 , 23 ]   def bubbleSort(aList):     aLen = len (aList)     for key in xrange (aLen - 1 ):          for x in xrange (aLen - key - 1 ):              if aList[x] > aList[x + 1 ]:                 aList[x], aList[x + 1 ] = aList[x + 1 ], aList[x]   print (alist) bubbleSort(alist) print (alist)

JavaScript/ECMAScript

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33

function bubbleSort(arr){     var temp; //先定义缓存     for ( var i=0;i<arr.length-1;i++){ //一共比较n-1趟          for ( var j=0;j<arr.length-i-1;j++){ //对当前无序区arr[i..n]自左向右扫描                 if (arr[j]>arr[j+1]){ //交换                          temp=arr[j];                          arr[j]=arr[j+1];                          arr[j+1]=temp;                      }                   }          }     return arr; }   Go   func BubbleSort(values[] int) {     flag := true     vLen := len(values)     for i := 0; i < vLen-1; i++ {          flag = true          for j := 0; j < vLen-i-1; j++ {              if values[j] > values[j+1] {                 values[j], values[j+1] = values[j+1], values[j]                 flag = false                 //continue              }           }           if flag {              break           }     } }

补充说明

交换排序的基本思想是：两两比较待排序记录的关键字，发现两个记录的次序相反时即进行交换，直到没有反序的记录为止。
    　应用交换排序基本思想的主要排序方法有：冒泡排序和快速排序。

冒泡排序

1、排序方法
    　将被排序的记录数组R[1..n]垂直排列，每个记录R[i]看作是重量为R[i].key的气泡。根据轻气泡不能在重气泡之下的原则，从下往上扫描数组R：凡扫描到违反本原则的轻气泡，就使其向上"飘浮"。如此反复进行，直到最后任何两个气泡都是轻者在上，重者在下为止。
（1）初始
　    R[1..n]为无序区。

（2）第一趟扫描
　    从无序区底部向上依次比较相邻的两个气泡的重量，若发现轻者在下、重者在上，则交换二者的位置。即依次比较(R[n]，R[n-1])，(R[n-1]，R[n-2])，…，(R[2]，R[1])；对于每对气泡(R[j+1]，R[j])，若R[j+1].key<R[j].key，则交换R[j+1]和R[j]的内容。
    　第一趟扫描完毕时，"最轻"的气泡就飘浮到该区间的顶部，即关键字最小的记录被放在最高位置R[1]上。

（3）第二趟扫描
　    扫描R[2..n]。扫描完毕时，"次轻"的气泡飘浮到R[2]的位置上……
    　最后，经过n-1 趟扫描可得到有序区R[1..n]
  注意：
　    第i趟扫描时，R[1..i-1]和R[i..n]分别为当前的有序区和无序区。扫描仍是从无序区底部向上直至该区顶部。扫描完毕时，该区中最轻气泡飘浮到顶部位置R[i]上，结果是R[1..i]变为新的有序区。

2、冒泡排序过程示例
    　对关键字序列为49 38 65 97 76 13 27 49的文件进行冒泡排序的过程【参见动画演示】

3、排序算法
（1）分析
    　因为每一趟排序都使有序区增加了一个气泡，在经过n-1趟排序之后，有序区中就有n-1个气泡，而无序区中气泡的重量总是大于等于有序区中气泡的重量，所以整个冒泡排序过程至多需要进行n-1趟排序。
    　若在某一趟排序中未发现气泡位置的交换，则说明待排序的无序区中所有气泡均满足轻者在上，重者在下的原则，因此，冒泡排序过程可在此趟排序后终止。为此，在下面给出的算法中，引入一个布尔量exchange，在每趟排序开始前，先将其置为FALSE。若排序过程中发生了交换，则将其置为TRUE。各趟排序结束时检查exchange，若未曾发生过交换则终止算法，不再进行下一趟排序。