冒泡排序

虛擬碼

function bubble_sort (array, length) {
    var i, j;
    for(i from 0 to length-1){
        for(j from 0 to length-1-i){
            if (array[j] > array[j+1])
                swap(array[j], array[j+1])
        }
    }
}
函數 泡沫排序 輸入 一個陣列名稱為array 其長度為length
    i 從 0 到 (length - 1)
        j 從 0 到 (length - 1 - i)
            如果 array[j] > array[j + 1]
                交換 array[j] 和 array[j + 1] 的值
            如果結束
        j迴圈結束
    i迴圈結束
函數結束

助記碼

i∈[0,N-1)               //循环N-1遍
   j∈[0,N-1-i)           //每遍循环要处理的无序部分
     swap(j,j+1)          //两两排序（升序/降序）

C語言

1 #include <stdio.h> 2  3 #define ARR_LEN 255 /* 數組長度上限 */ 4 #define elemType int /* 元素類型 */ 5  6 /* 泡沫排序 */ 7 /* 1. 從當前元素起，向後依次比較每一對相鄰元素，若逆序則互換 */ 8 /* 2. 對所有元素均重複以上步驟，直至最後一個元素 */ 9 /* elemType arr[]: 排序目標數組; int len: 元素個數 */10 void bubbleSort (int arr[], int len)11 {12 13 int i, j,temp;14 Boolean exchanged = true;15 
16 for (i=0; exchanged && i<len-1; i++) /* 外迴圈為排序趟數，len個數進行len-1趟,只有交換過,exchanged值為true才有執行迴圈的必要,否則exchanged值為false不執行迴圈 */17 for (j=0; j<len-1-i; j++) 
18 { /* 內迴圈為每趟比較的次數，第i趟比較len-i次  */19 
20 exchanged = false;21 
22 if (arr[j] > arr[j+1])23 { /* 相鄰元素比較，若逆序則互換（升序為左大於右，逆序反之） */24 temp = arr[j];25 arr[j] = arr[j+1];26 arr[j+1] = temp;27 exchanged = true; /*只有數值互換過, exchanged才會從false變成true,否則數列已經排序完成,exchanged值仍然為false,沒必要排序 */28 }29 }30 }31 32 int main (void) {33 int arr[ARR_LEN] = {3,5,1,-7,4,9,-6,8,10,4};34 int len = 10;35 int i;36 
37 bubbleSort (arr, len);38 
39 for (i=0; i<len; i++)40 printf ("%d\t", arr[i]);41 putchar ('\n');42 
43 return 0;44 }

C++

#include <iostream>using namespace std;template<typename T> //整数或浮点数皆可使用,若要使用类(class)或结构体(struct)时必须重载大于(>)运算符void bubble_sort(T arr[], int len) {
int i, j;
for (i = 0; i < len - 1; i++)
for (j = 0; j < len - 1 - i; j++)
if (arr[j] > 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 < 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 < len; i++)
cout << arrf[i] << ' '<<endl;
return 0;}

C#

static void BubbleSort(int[] intArray) {
    int temp = 0;
    bool swapped;
    for (int i = 0; i < intArray.Length; i++)
    {
        swapped = false;
        for (int j = 0; j < intArray.Length - 1 - i; j++)
            if (intArray[j] > intArray[j + 1])
            {
                temp = intArray[j];
                intArray[j] = intArray[j + 1];
                intArray[j + 1] = temp;
                if (!swapped)
                    swapped = true;
            }
        if (!swapped)
            return;
    }}

JAVA

public static void bubbleSort(int[] arr) {
    int i, temp, len = arr.length;
    boolean changed;
    do {
      changed = false;
      len-=1;
      for (i = 0; i < len; i++) {
        if (arr[i] > arr[i + 1]) {
          temp = arr[i];
          arr[i] = arr[i + 1];
          arr[i + 1] = temp;
          changed = true;
        }
      }
    } while (changed);
  }
  
  public static <T extends Comparable<T>> void bubbleSort2(T[] arr) {
        int n = arr.length;
        int newn;
        do {
            newn = 0;
            for (int i = 1; i < n; i++)
                if (arr[i - 1].compareTo(arr[i]) > 0) {
                    swap(arr, i - 1, i);
                    newn = i;
                }
            n = newn;
        } while (newn > 0);
  }

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] > self[j + 1]
      end
    end
    self
  endendputs [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 < this.length - 1; i++)
for (j = 0; j < this.length - 1 - i; j++)
if (this[j] > 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 < 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]>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):
        for j in range(i + 1,list_len):
            if new_list[i] > new_list[j]:
                new_list[i], new_list[j] = new_list[j], new_list[i]
    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) < 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("共經過了" & count & "次排序")

  '泡沫排序由小到大的程式
      
   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) > b(j + 1) Then switch(b(j), b(j + 1))
           count += 1
           check = True
        Next
        If chk = False Then Exit For
    Next
  
    MsgBox("共經過了" & count & "次的排序")
   
   '兩數值交換程式
    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(&$x, &$y) {
$t = $x;
$x = $y;
$y = $t;}function bubble_sort(&$arr) {//php的陣列視為基本型別，所以必須用傳參考才能修改原陣列
for ($i = 0; $i < count($arr) - 1; $i++)
for ($j = 0; $j < count($arr) - 1 - $i; $j++)
if ($arr[$j] > $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 < count($arr); $i++)
echo $arr[$i] . ' ';

Rust

pub fn bubble_sort(a: &mut[i32]){    for i in 0..a.len() {        for j in i..a.len() {            if a[i] > a[j] {                a.swap(i, j);            }        }    }}
呼叫：
    let mut a = [5,4,7,1,9];    bubble_sort(&mut a);    println!("{:?}", a);

Go

// BubbleSort 冒泡排序. data必须实现sort包中的Interface接口func BubbleSort(data sort.Interface) {
n := data.Len()
for i := 0; i < n-1; i++ {
isChanged := false
for j := 0; j < 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
data := sort.IntSlice{22, 34, 3, 40, 18, 4}
BubbleSort(data)

Objective-C

1 - (NSArray*) bubbleSort: (NSArray *) unsortedArray { 2     if (unsortedArray.count <= 1) { 3         return unsortedArray; 4     } 5     
 6     NSMutableArray *sortedArray = [unsortedArray mutableCopy]; 7     
 8     for (int i = 0; i < sortedArray.count-1; i++) { 9         BOOL exchanged = NO;10         for (int j = 0; j< sortedArray.count-1-i; j++) {11             if ([sortedArray[j] integerValue] > [sortedArray[j+1] integerValue]) {12                 [sortedArray exchangeObjectAtIndex:j withObjectAtIndex:j+1];13                 exchanged = YES;14             }15         }16         if (!exchanged) {17             break;18         }19     }20     
21     return [sortedArray copy];22 }

Swift

1 func bubbleSort(unsortedArray: inout [Int]){ 2     guard unsortedArray.count > 1 else{ 3         return 
 4     } 5     
 6     for i in 0 ..< unsortedArray.count-1 { 7         var exchanged = false 8         for j in 0 ..< unsortedArray.count-1-i { 9             if unsortedArray[j] > unsortedArray[j+1] {10                 unsortedArray.swapAt(j, j+1)11                 exchanged = true12             }13         }14         if !exchanged {15             break16         }17     }18 }19 20 // Test21 var list = [2, 3, 5, 7, 4, 8, 6 ,10 ,1, 9]22 print(list)  
23 bubbleSort(unsortedArray: &list)24 print(list)