冒泡排序详解-简单易学，轻松上手

定义

冒泡排序，英文名Bubble Sort，这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端（升序或降序排列），就如同碳酸饮料中二氧化碳的气泡最终会上浮到顶端一样，故名“冒泡排序”。

排序过程

1. 以升序（从小到大排序）为例，冒泡排序中，每一轮排序都会将相邻两元素进行比较，如果前一个元素大于后一个元素，则将两元素位置交换，这样一轮排序完成之后，最大的元素就会处于最后的位置。

2. 然后进行第二轮排序，过程同步骤1类似，只是最后一个元素不再参与比较，因为它已经是最大的已经完成排序。

3. 假设一共由n个元素，那么进行n-1轮的排序后，元素就完成了从小到大的排序。为什么是n-1，假设有10个元素，那么进行过9轮排序后，后面的9个元素已经都是比第一个元素大的了，此时实际排序已经完成。

4. 每一轮排序需要进行几次比较。比如有10个元素，第一轮需要比较9次，第二轮需要对9个元素排序，需要比较8次，以此类推，第i轮排序需要比较的次数为n-i。

以上可以知道 对于n个元素的数组，需要进行n-1轮排序。 第m轮排序需要比较的次数为n-i。

案例讲解

#include <iostream>

#define N 12

using namespace std;

int main() {

    int numbers[N] = {12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1};
    // N - 1轮排序
    for (int i = 1; i <= N - 1; i++) {
    	// 每一轮比较N - i次，数组元素下标从0开始
        for (int j = 0; j < N - i; j++) {
            if (numbers[j] > numbers[j+1]) {
            	// 元素交换
                int tmp = numbers[j];
                numbers[j] = numbers[j+1];
                numbers[j+1] = tmp;
            }
        } 
        cout<<"第"<<i<<"轮排序完成：";
        for (int k = 0; k < N; k++) {
            cout<<numbers[k]<<" ";
        }
        cout<<endl;
    }

    cout<<"排序完成：";
    for (int i = 0; i < N; i++) {
        cout<<numbers[i]<<" ";
    }
    
    return 0;
}

程序运行结果如下：

第1轮排序完成：11 10 9 8 7 6 5 4 3 2 1 12 
第2轮排序完成：10 9 8 7 6 5 4 3 2 1 11 12 
第3轮排序完成：9 8 7 6 5 4 3 2 1 10 11 12 
第4轮排序完成：8 7 6 5 4 3 2 1 9 10 11 12 
第5轮排序完成：7 6 5 4 3 2 1 8 9 10 11 12 
第6轮排序完成：6 5 4 3 2 1 7 8 9 10 11 12 
第7轮排序完成：5 4 3 2 1 6 7 8 9 10 11 12 
第8轮排序完成：4 3 2 1 5 6 7 8 9 10 11 12 
第9轮排序完成：3 2 1 4 5 6 7 8 9 10 11 12 
第10轮排序完成：2 1 3 4 5 6 7 8 9 10 11 12 
第11轮排序完成：1 2 3 4 5 6 7 8 9 10 11 12 
排序完成：1 2 3 4 5 6 7 8 9 10 11 12 

让编程变得简单，欢迎关注公众号：无限无羡。