冒泡排序

冒泡排序（）又称为泡式排序，是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢「浮」到数列的顶端。
冒泡排序对formula_1个项目需要O(formula_2)的比较次数，且可以原地排序。尽管这个演算法是最简单了解和实作的排序算法之一，但它对于包含大量的元素的数列排序是很没有效率的。
冒泡排序是与插入排序拥有相等的渐近时间复杂度，但是两种算法在需要的交换次数却很大地不同。在最坏的情况，冒泡排序需要formula_3次交换，而插入排序只要最多formula_4交换。冒泡排序的实现（类似下面）通常会对已经排序好的数列拙劣地执行（formula_3），而插入排序在这个例子只需要formula_4个运算。因此很多现代的演算法教科书避免使用冒泡排序，而用插入排序取代之。冒泡排序如果能在内部回圈第一次执行时，使用一个旗标来表示有无需要交换的可能，也可以把最优情况下的复杂度降低到formula_4。在这个情况，已经排序好的数列就无交换的需要。若在每次走访数列时，把走访顺序反过来，也可以稍微地改进效率。有时候称为鸡尾酒排序，因为演算法会从数列的一端到另一端之间穿梭往返。
冒泡排序演算法的运作如下：
由于它的简洁，冒泡排序通常被用来对于程式设计入门的学生介绍演算法的概念。
助记码.
 i∈[0,N-1) //循环N-1遍
 j∈[0,N-1-i) //每遍循环要处理的无序部分
 swap(j,j+1) //两两排序（升序/降序）
实作范例.
C语言.
/* 泡沫排序 */
/* 1. 从当前元素起，向后依次比较每一对相邻元素，若逆序则互换 */
/* 2. 对所有元素均重复以上步骤，直至最后一个元素 */
/* elemType arr[]: 排序目标数组; int len: 元素个数 */
void bubbleSort (int arr[], int len)
 int i, j,temp;
 _Bool exchanged = true;
 for (i=0; exchanged &amp;&amp; i&lt;len-1; i++){ /* 外回圈为排序趟数，len个数进行len-1趟,只有交换过,exchanged值为true才有必要执行回圈,否则exchanged值为false不执行回圈 */
 exchanged = false;
 for (j=0; j&lt;len-1-i; j++) 
 { /* 内回圈为每趟比较的次数，第i趟比较len-i次 */
 if (arr[j] &gt; arr[j+1])
 { /* 相邻元素比较，若逆序则互换（升序为左大于右，逆序反之） */
 temp = arr[j];
 arr[j] = arr[j+1];
 arr[j+1] = temp;
 exchanged = true; /*只有数值互换过, exchanged才会从false变成true,否则数列已经排序完成,exchanged值仍然为false,没必要排序 */
int main (void) {
 int arr[ARR_LEN] = {3,5,1,-7,4,9,-6,8,10,4};
 int len = 10;
 int i;
 bubbleSort (arr, len);
 for (i=0; i&lt;len; i++)
 printf ("%d\t", arr[i]);
 putchar ('\n');
 return 0;
C++.
using namespace std;
template&lt;typename T&gt; //整数或浮点数皆可使用,若要使用类(class)或结构体(struct)时必须重载大于(&gt;)运算符
void bubble_sort(T arr[], int len) {
 int i, j;
 for (i = 0; i &lt; len - 1; i++)
 for (j = 0; j &lt; len - 1 - i; j++)
 if (arr[j] &gt; arr[j + 1])
 swap(arr[j], arr[j + 1]);
int main() {
 int arr[] = { 61, 17, 29, 22, 34, 60, 72, 21, 50, 1, 62 };
 int len = (int) sizeof(arr) / sizeof(*arr);
 bubble_sort(arr, len);
 for (int i = 0; i &lt; len; i++)
 cout « arr[i] « ' ';
 cout « endl;
 float arrf[] = { 17.5, 19.1, 0.6, 1.9, 10.5, 12.4, 3.8, 19.7, 1.5, 25.4, 28.6, 4.4, 23.8, 5.4 };
 len = (float) sizeof(arrf) / sizeof(*arrf);
 bubble_sort(arrf, len);
 for (int i = 0; i &lt; len; i++)
 cout « arrf[i] « ' '«endl;
 return 0;
C#.
private int[] BubbleSort(int[] array)
 var temp = 0;
 for (int i = 0; i &lt; array.Length - 1; i++)
 for (int j = 0; j &lt; array.Length - 1 - i; j++)
 if (array[j] &gt; array[j + 1])
 temp = array[j];
 array[j] = array[j + 1];
 array[j + 1] = temp;
 return array;
JAVA.
private int[] bubbleSort(int[] array) {
 int temp;
 for (int i = 0; i &lt; array.length - 1; i++) {
 boolean Flag = false; // 是否发生交换。没有交换，提前跳出外层循环
 for (int j = 0; j &lt; array.length - 1 - i; j++) {
 if (array[j] &gt; array[j + 1]) {
 temp = array[j];
 array[j] = array[j + 1];
 array[j + 1] = temp;
 Flag = true;
 if (!Flag)
 break;
 return array;
Ruby.
class Array
 def bubble_sort!
 for i in 0...(size - 1)
 for j in 0...(size - i - 1)
 self[j], self[j + 1] = self[j + 1], self[j] if self[j] &gt; self[j + 1]
 end
 end
 self
 end
end
puts [22, 34, 3, 32, 82, 55, 89, 50, 37, 5, 64, 35, 9, 70].bubble_sort!
JavaScript.
Array.prototype.bubble_sort = function() {
 var i, j, temp;
 for (i = 0; i &lt; this.length - 1; i++)
 for (j = 0; j &lt; this.length - 1 - i; j++)
 if (this[j] &gt; this[j + 1]) {
 temp = this[j];
 this[j] = this[j + 1];
 this[j + 1] = temp;
 return this;
var num = [22, 34, 3, 32, 82, 55, 89, 50, 37, 5, 64, 35, 9, 70];
num.bubble_sort();
for (var i = 0; i &lt; num.length; i++)
 document.body.innerHTML += num[i] + " ";
Pascal.
输入：（在程式同目录下的文本文件：input.txt）
　一行：等待排序的数（用空格隔开）；
　实例：194 638 124 482 469 245 852 294 484 243 623
输出：（在程式同目录下的文本文件：output.txt）
　一行：已经排好的数（从小到大）；
　实例：124 194 243 245 294 469 482 484 623 638 852
procedure swap(j:longint); //交换过程
begin
 a[j]:=a[j] xor a[j+1];
 a[j+1]:=a[j] xor a[j+1];
 a[j]:=a[j] xor a[j+1];
end;
procedure bubble_sort; //排序过程
var
 i,j:longint;
 flag:boolean; //flag标志：若一次排序未发现数据交换，则说明数据已经有序，可以结束排序过程
begin
 for i:=n-1 downto 1 do 
 begin
 flag:=true;
 for j:=1 to i do
 begin
 if a[j]&gt;a[j+1] then 
 begin
 swap(j);
 flag:=false;
 end;
 end;
 if flag then exit;
 end;
end;
Python.
def bubble_sorted(iterable):
 new_list = list(iterable)
 list_len = len(new_list)
 for i in range(list_len-1):
 for j in range(list_len - i - 1):
 if new_list[j] &gt; new_list[j + 1]:
 new_list[j], new_list[j + 1] = new_list[j + 1], new_list[j]
 return new_list
范例：
testlist = [27, 33, 28, 4, 2, 26, 13, 35, 8, 14]
print('sorted:', bubble_sorted(testlist))
输出：
sorted: [2, 4, 8, 13, 14, 26, 27, 28, 33, 35]
VB.NET.
 '泡沫排序由大到小的程式，预先产生一储存乱数内容的阵列B，使用中断点check，
 'switch 为自定两数交换的sub
 Dim i, j, count As Integer
 For i = 0 To UBound(b) - 1
 Dim check As Boolean = False '进入排序后设定一布林变数令其初值为false
 For j = 0 To UBound(b) - 1 - i
 If b(j) &lt; b(j + 1) Then switch(b(j), b(j + 1))
 check = True '进行检查程序，若符合交换条件即进行两数值交换(呼叫sub程序) 并于交换后
 '将check的值变更为true(表示有进行交换动作，则此数列尚未呈现最终排列序)，
 '离开本层for回圈后再度将check值重设成false
 count += 1 
 Next
 If check = False Then Exit For '检查进入回圈后是否进行过数值交换，若check值为false，
 '则表示排序进行到此时所有数列的值已呈现期望中的顺序，
 '因此尚未进行完的排序检查动作可提早结束以提升效率。
 Next
 MsgBox("共经过了" &amp; count &amp; "次排序")
 '泡沫排序由小到大的程式
 Dim i, j, count As Integer
 Dim check As Boolean
 For i = 0 To UBound(b) - 1
 check=false
 For j = 0 To UBound(b) - 1 - i
 If b(j) &gt; b(j + 1) Then switch(b(j), b(j + 1))
 count += 1
 check = True
 Next
 If chk = False Then Exit For
 Next
 MsgBox("共经过了" &amp; count &amp; "次的排序")
 '两数值交换程式
 Private Sub switch(ByRef a as integer, ByRef b as integer)
 Dim c As Integer
 c = a
 a = b
 b = c
 End Sub
PHP.
function swap(&amp;$x, &amp;$y) {
 $t = $x;
 $x = $y;
 $y = $t;
function bubble_sort(&amp;$arr) {//php的阵列视为基本型别，所以必须用传参考才能修改原阵列
 for ($i = 0; $i &lt; count($arr) - 1; $i++)
 for ($j = 0; $j &lt; count($arr) - 1 - $i; $j++)
 if ($arr[$j] &gt; $arr[$j + 1])
 swap($arr[$j], $arr[$j + 1]);
$arr = array(21, 34, 3, 32, 82, 55, 89, 50, 37, 5, 64, 35, 9, 70);
bubble_sort($arr);
for ($i = 0; $i &lt; count($arr); $i++)
 echo $arr[$i] . ' ';
Rust.
pub fn bubble_sort(a: &amp;mut[i32]){
 for i in 0..a.len() {
 for j in i..a.len() {
 if a[i] &gt; a[j] {
 a.swap(i, j);
调用：
 let mut a = [5,4,7,1,9];
 bubble_sort(&amp;mut a);
 println!("{:?}", a);
Go.
// BubbleSort 冒泡排序. data必须实现sort包中的Interface接口
func BubbleSort(data sort.Interface) {
 n := data.Len()
 for i := 0; i &lt; n-1; i++ {
 isChanged := false
 for j := 0; j &lt; n-1-i; j++ {
 if data.Less(j, j+1) {
 data.Swap(j, j+1)
 isChanged = true
 if !isChanged {
 break
调用:
 // declare a array
 // this array must implenet sort.Inerface
 BubbleSort(data)
Objective-C.
- (NSArray*) bubbleSort: (NSArray *) unsortedArray {
 if (unsortedArray.count &lt;= 1) {
 return unsortedArray;
 
 NSMutableArray *sortedArray = [unsortedArray mutableCopy];
 for (int i = 0; i &lt; sortedArray.count-1; i++) {
 BOOL exchanged = NO;
 for (int j = 0; j&lt; sortedArray.count-1-i; j++) {
 if ([sortedArray[j] integerValue] &gt; [sortedArray[j+1] integerValue]) {
 [sortedArray exchangeObjectAtIndex:j withObjectAtIndex:j+1];
 exchanged = YES;
 if (!exchanged) {
 break;
 return [sortedArray copy];
Swift.
func bubbleSort(unsortedArray: inout [Int]){
 guard unsortedArray.count &gt; 1 else{
 return 
 
 for i in 0 ..&lt; unsortedArray.count-1 {
 var exchanged = false
 for j in 0 ..&lt; unsortedArray.count-1-i {
 if unsortedArray[j] &gt; unsortedArray[j+1] {
 unsortedArray.swapAt(j, j+1)
 exchanged = true
 if !exchanged {
 break
// Test
var list = [2, 3, 5, 7, 4, 8, 6 ,10 ,1, 9]
print(list) 
bubbleSort(unsortedArray: &amp;list)
print(list) 
Shell.
read -p "Please enter a sequence: " -a num
for ((i=0;i&lt;$[${#num[*]}-1];i++));do
 for((j=0;j&lt;$[$[${#num[*]}-1]-$i];j++));do
 if [ ${num[$j]} -gt ${num[$[$j+1]]} ];then
 num[$[$j+1]]=$A
 fi
 done
done
IDL.
FUNCTION BubbleSort, arr
 FOR i = 0, N_ELEMENTS(arr) - 2 DO BEGIN
 FOR j = i + 1, N_ELEMENTS(arr) - 1 DO BEGIN
 IF arr[i] GT arr[j] THEN BEGIN
 temp = arr[i] &amp; arr[i] = arr[j] &amp; arr[j] = temp
 ENDIF
 ENDFOR
 ENDFOR
 RETURN, arr
END
Julia (程式语言).
function BubbleSort(A)
 n = length(A)
 for i = 1:n
 for j = 1:(n-i)
 if(A[j]&gt;A[j+1])
 A[j+1],A[j] = A[j],A[j+1]
 end
 end
 end
 return A
end
A = [16,586,1,31,354,43,3]
print(A) # Original Array
print(BubbleSort(A)) # Bubble Sort Array