冒泡排序（Bubble Sort），是一種計算機科學領域的較簡單的排序算法。

它重復地走訪過要排序的元素列，依次比較兩個相鄰的元素，如果順序（如從大到小、首字母從Z到A）錯誤就把他們交換過來。走訪元素的工作是重復地進行直到?jīng)]有相鄰元素需要交換，也就是說該元素列已經(jīng)排序完成

算法原理
冒泡排序算法的原理如下： ^[1]

1. 比較相鄰的元素。如果第一個比第二個大，就交換他們兩個。 ^[1]
2. 對每一對相鄰元素做同樣的工作，從開始第一對到結(jié)尾的最后一對。在這一點，最后的元素應該會是最大的數(shù)。 ^[1]
3. 針對所有的元素重復以上的步驟，除了最后一個。 ^[1]
4. 持續(xù)每次對越來越少的元素重復上面的步驟，直到?jīng)]有任何一對數(shù)字需要比較。

冒泡排序最好的時間復雜度為O(n)
平均時間復雜度為O(n^2)

#C：
#include <stdio.h>
 
#define ARR_LEN 255 /*數(shù)組長度上限*/
#define elemType int /*元素類型*/
 
/* 冒泡排序 */
/* 1. 從當前元素起，向后依次比較每一對相鄰元素，若逆序則交換 */
/* 2. 對所有元素均重復以上步驟，直至最后一個元素 */
/* elemType arr[]: 排序目標數(shù)組; int len: 元素個數(shù) */
void bubbleSort (elemType arr[], int len) {
    elemType temp;
    int i, j;
    for (i=0; i<len-1; i++) /* 外循環(huán)為排序趟數(shù)，len個數(shù)進行l(wèi)en-1趟 */
        for (j=0; j<len-1-i; j++) { /* 內(nèi)循環(huán)為每趟比較的次數(shù)，第i趟比較len-i次 */
            if (arr[j] > arr[j+1]) { /* 相鄰元素比較，若逆序則交換（升序為左大于右，降序反之） */
                temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
            }
        }
}
 
int main (void) {
    elemType 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<len; i++)
        printf ("%d\t", arr[i]);
    putchar ('\n');
     
    return 0;
}

#OC
for (int i = 0; i<result.count-1; i++) {
        for (int j = 0; j<result.count-1-i; j++) {
            NSInteger left = [result[j] integerValue];
            NSInteger right = [result[j+1] integerValue];
            if (left>right) {
                [result exchangeObjectAtIndex:j withObjectAtIndex:j+1];
            }
        }
    }

#Swift
func bubbleSort(_ nums: inout [Int]) {
    let n = nums.count
    for i in 0..<n-1 {
        for j in 0..<(n - 1 - i) {
            if nums[j] > nums[j + 1] {
                nums.swapAt(j, j + 1)
            }
        }
    }
    print(nums)
}
 
var nums = [1,3,7,8,9]
bubbleSort(&nums)