排序算法——冒泡排序

算法描述（升序）：

1、从初始位置开始，比较相邻两个元素的大小，即位置（0，1），如果“前元素”大于“后元素”，就将两个元素交换位置；

2、继续比较下一对相邻的元素，即位置（1，2），如果“前元素”大于“后元素”，就将两个元素交换位置；

3、重复上述步骤，直至到最后一对相邻元素，则此时整个数列的最大的元素，位于数列的末尾位置；

4、继续排序，重复一次步骤1、2。进行步骤3时，只需要比较到倒数第二对相邻元素即可，因为此时末尾已经是最大的元素。排序结束，此时数列最后两个元素，即是数列最大的两个元素。

5、每进行一次排序，数列的尾部就会按照升序添加一个新的元素。（即不用每次都一直比较到最后，第一次比较，比到最后，第二次比较，比到倒数第二个，第三次比较，比到倒数第三个，……）

图解（网图，侵删）：

代码：

#include <iostream>
#include <vector>
using namespace std;
void bubbleSort(vector<int> &vec);
int main()
{
    vector<int> a = {86, 76, 62, 58, 77, 85, 92, 80, 96, 88, 77, 67, 80, 68, 88, 87, 64, 59, 61, 76};
    bubbleSort(a);
    for (auto i : a)
        cout << i << " ";
}
void bubbleSort(vector<int> &vec)
{
    bool tag;
    for (int i = 0; i < (int)vec.size() - 1; i++)
    {
        tag = true;
        for (int j = 0; j < (int)vec.size() - i - 1; j++)
        {
            if (vec[j] > vec[j + 1])
            {
                swap(vec[j], vec[j + 1]);
                tag = false;
            }
        }
        if (tag)
            return;
    }
}

算法分析：

最优情况：数列刚好是升序，一趟扫描就可以完成排序，比较次数为n-1，时间复杂度为O(n)

最坏情况：数列刚好是降序，需要进行n-1躺排序，比较次数为(n-1)+(n-2)+(n-3)+……+1=n*(n-1)/2,时间复杂度为O(n*n)

平均时间复杂度：O(n*n)

稳定性：相同元素的前后顺序没有改变（因为是当“>"的时候进行交换，不是”>=“），所以是一种稳定排序算法