n个记录进行冒泡排序的方法是：首先将第一个记录的关键字和第二个记录的关键字进行比较，若为逆序，则交换，然后继续比较；依次类推，直到比较n-1与n；这是第一趟冒泡排序。然后进行第二趟，对前n-1个遍历排序，最多进行n-1趟。优化：若某趟没有进行元素交换，则可以直接结束排序。

冒泡排序是一种稳定的排序方法，其时间复杂度为，空间复杂度为O（1）

算法实现

//  非递减有序排序
void bubbleSort_ASC(vector<int> &data)
{
    int size = data.size();     //  数据个数

    bool flg = false;           // 当次循环是否发生位置交换
    // 最多size-1趟排序
    for(int i = 0; i < size  - 1; i++)
    {
        flg = false;
        // 从末尾开始遍历， i 之前是排好序的
        for(int j = size - 1;  j > i; j--)
        {
            // 前数大于后数，交换位置
            if(data.at(j - 1) > data.at(j))
            {
                flg = true;
                swapNum(data.at(j - 1), data.at(j));
            }
        }

        // 本趟未发生位置交换，数据已排好序
        if(flg == false)
        {
            break;
        }
    }
}

//  非递增有序排序
void bubbleSort_DESC(vector<int> &data)
{
    int size = data.size();     //  数据个数

    bool flg = false;           // 当次循环是否发生位置交换
    // 最多size-1趟排序
    for(int i = 0; i < size  - 1; i++)
    {
        flg = false;
        // 从头开始遍历， size - i 之后是排好序的
        for(int j = 1;  j < size - i; j++)
        {
            // 前数小于后数，交换位置
            if(data.at(j - 1) < data.at(j))
            {
                flg = true;
                swapNum(data.at(j - 1), data.at(j));
            }
        }

        // 本趟未发生位置交换，数据已排好序
        if(flg == false)
        {
            break;
        }
    }
}

//  排序,合并成一个函数, bSort
// true ： 非递减有序排序
// false:  非递增有序排序
void bubbleSort(vector<int> &data, const bool &bSort)
{
    int size = data.size();     //  数据个数

    bool flg = false;           // 当次循环是否发生位置交换
    // 最多size-1趟排序
    for(int i = 0; i < size  - 1; i++)
    {
        flg = false;
        // 从头开始遍历， size - i 之后是排好序的
        for(int j = 1;  j < size - i; j++)
        {
            // true ： 非递减有序排序
            // false: 非递增有序排序
            bool nRet = bSort ? (data.at(j - 1) > data.at(j)) : (data.at(j - 1) < data.at(j));
            if(nRet)
            {
                flg = true;
                swapNum(data.at(j - 1), data.at(j));
            }
        }

        // 本趟未发生位置交换，数据已排好序
        if(flg == false)
        {
            break;
        }
    }
}

总

#include <iostream>
#include <vector>
#include <stdlib.h>
#include <time.h>
using namespace std;

// 交换数值
void swapNum(int &a, int &b)
{
    int tmp = a;
    a   = b;
    b   =  tmp;
}

//  在控制台打印
void dadaCout(const vector<int> &data)
{
    int size = data.size();
    for(int i = 0; i < size; i++)
    {
        cout << data.at(i) << " " ;
    }

    cout << endl;
}

//  非递减有序排序
void bubbleSort_ASC(vector<int> &data)
{
    int size = data.size();     //  数据个数

    bool flg = false;           // 当次循环是否发生位置交换
    // 最多size-1趟排序
    for(int i = 0; i < size  - 1; i++)
    {
        flg = false;
        // 从末尾开始遍历， i 之前是排好序的
        for(int j = size - 1;  j > i; j--)
        {
            // 前数大于后数，交换位置
            if(data.at(j - 1) > data.at(j))
            {
                flg = true;
                swapNum(data.at(j - 1), data.at(j));
            }
        }

        // 本趟未发生位置交换，数据已排好序
        if(flg == false)
        {
            break;
        }
    }
}

//  非递增有序排序
void bubbleSort_DESC(vector<int> &data)
{
    int size = data.size();     //  数据个数

    bool flg = false;           // 当次循环是否发生位置交换
    // 最多size-1趟排序
    for(int i = 0; i < size  - 1; i++)
    {
        flg = false;
        // 从头开始遍历， size - i 之后是排好序的
        for(int j = 1;  j < size - i; j++)
        {
            // 前数小于后数，交换位置
            if(data.at(j - 1) < data.at(j))
            {
                flg = true;
                swapNum(data.at(j - 1), data.at(j));
            }
        }

        // 本趟未发生位置交换，数据已排好序
        if(flg == false)
        {
            break;
        }
    }
}

//  排序,合并成一个函数, bSort
// true ： 非递减有序排序
// false:  非递增有序排序
void bubbleSort(vector<int> &data, const bool &bSort)
{
    int size = data.size();     //  数据个数

    bool flg = false;           // 当次循环是否发生位置交换
    // 最多size-1趟排序
    for(int i = 0; i < size  - 1; i++)
    {
        flg = false;
        // 从头开始遍历， size - i 之后是排好序的
        for(int j = 1;  j < size - i; j++)
        {
            // true ： 非递减有序排序
            // false: 非递增有序排序
            bool nRet = bSort ? (data.at(j - 1) > data.at(j)) : (data.at(j - 1) < data.at(j));
            if(nRet)
            {
                flg = true;
                swapNum(data.at(j - 1), data.at(j));
            }
        }

        // 本趟未发生位置交换，数据已排好序
        if(flg == false)
        {
            break;
        }
    }
}

int main()
{
    srand((unsigned)time(NULL));        //随机数种子

    vector<int> data;
    for(int i = 0; i < 15; i++)
    {
        // 获取两位数的随机数
        data.push_back(rand() % 90 + 10);
    }

    cout << "data:                  ";
    dadaCout(data);

    bubbleSort_ASC(data);
    cout << "bubbleSort_ASC:        ";
    dadaCout(data);

    bubbleSort_DESC(data);
    cout << "bubbleSort_DESC:       ";
    dadaCout(data);

    bubbleSort(data, true);
    cout << "bubbleSort_ASC_true:   ";
    dadaCout(data);

    bubbleSort(data, false);
    cout << "bubbleSort_DESC_false: ";
    dadaCout(data);

    return 0;
}