排序算法之冒泡排序

冒泡排序（Bubble Sort），是一种计算机科学领域的较简单的排序算法，冒泡排序的特点是调整相邻的两个对象的位置，每进行一次内循环，就可以将最大值调整到最后，这样下次就不需要考虑它了，冒泡排序的时间复杂度为O(N^2)，虽然时间上不占有优势，但是冒泡排序的代码简单，实现难度低。

实例分析：

以数组 arr = [5, 1, 4, 2, 8] 为例说明，加粗的数字表示每次循环要比较的两个数字：

第一次外循环

( 5 1 4 2 8 ) → ( 1 5 4 2 8 )， 5 > 1 交换位置
( 1 5 4 2 8 ) → ( 1 4 5 2 8 )， 5 > 4 交换位置
( 1 4 5 2 8 ) → ( 1 4 2 5 8 )， 5 > 2 交换位置
( 1 4 2 5 8 ) → ( 1 4 2 5 8 )， 5 < 8 位置不变

第二次外循环（除开最后一个元素8，对剩余的序列）

( 1 4 2 5 8 ) → ( 1 4 2 5 8 )， 1 < 4 位置不变
( 1 4 2 5 8 ) → ( 1 2 4 5 8 )， 4 > 2 交换位置
( 1 2 4 5 8 ) → ( 1 2 4 5 8 )， 4 < 5 位置不变

第三次外循环（除开已经排序好的最后两个元素，可以注意到上面的数组其实已经排序完成，但是程序本身并不知道，所以还要进行后续的循环，直到剩余的序列为 1）

( 1 2 4 5 8 ) → ( 1 2 4 5 8 )
( 1 2 4 5 8 ) → ( 1 2 4 5 8 )

第四次外循环（最后一次）
( 1 2 4 5 8 ) → ( 1 2 4 5 8 )

 

 

Python实现：

def bubble_sort(items):
    list_len = len(items) - 1
    if list_len <= 1:
        return items
    for index in range (0, list_len):
        for sub_index in range (0, list_len - index):
            if (items[sub_index] > items[sub_index + 1]):
                items[sub_index], items[sub_index + 1] = items[sub_index + 1], items[sub_index]
    return items
lists = [10, 11, 3, 4, 8, 12, 6, 7, 1]
print('final:', bubble_sort(lists))

C++实现：

#include<iostream>
using namespace std;

template <typename T>
void my_swap (T &a, T &b) {
    T temp = a;
    a = b;
    b = temp;
}

template <typename T>
void bubble_sort(T arr[], int len) {
    for (int i = 0; i < len - 1; ++i) {
        for (int j = 0; j < len - 1 - i; ++j) {
            if (arr[j] > arr[j + 1]) {
                my_swap(arr[j], arr[j + 1]);
            }
        }
    }
}

int main() {
    int arr[] = {1, 0, 3, 56, 32, 2, 3, 100, 35};
    int len = sizeof(arr) / sizeof(arr[0]);
    bubble_sort(arr, len);
    std::cout << "sort over:" << std::endl;
    for (int i = 0; i < len; ++i) {
        std::cout << arr[i] << std::endl;
    }
}