几个基础算法介绍和实现——冒泡排序

冒泡排序

看名字就很熟悉很形象，接触到的第一次排序算法就是冒泡算法

冒泡排序法算法描述

1. 依次比较相邻二个数据,如果前面数据大于后面的数据就将二个数据交换。

2. 对长度为N的组数,从第0个遍历到第N-1个,此时最大的一个数据就“沉”到数组第N-1个位置

3. N=N-1,重复第二个步骤,知道N=1结束

冒泡实现
void Sort::BubbleSort(int type, int (&a)[10], int n){

    int i, j;
    bool flag;
    int position;

    switch (type){
        case 1://基础冒泡
            int i, j;
            for (i = 0; i < n; i++)
            {
                for (j = 1; j < n - i; j++)
                {
                    if (a[j - 1] > a[j])swap(a[j - 1], a[j]);
                }
            }
            break;
        case 2://改进冒泡(如果有一趟冒泡循环中没有交换动作发生，则认为排序完成)
                i = n;
                flag = true;
                while (flag)
                {
                    flag = false;
                    for (j = 1; j < i; j++)
                    {
                        if (a[j - 1] > a[j])
                        {
                            swap(a[j - 1], a[j]);
                            flag = true;
                        }
                    }                       
                    i--;
                }           
            break;
        case 3://改进冒泡(记录上次冒泡后最后发生排序的位置，在此位置后的元素已经有序，然后只要对该位置以前的元素排序)
            position = n;
            while (position > 0)
            {
                i = position;
                position = 0;
                for (j = 1; j < i; j++)
                { 
                    if (a[j - 1] > a[j])
                    {
                        swap(a[j - 1], a[j]);   
                        position = j;
                    }                   
                }
            }
            break;
        default:
            break;
        }
}


int main(void){

    Sort m_sort;
    int a[10] = { 34, 8, 64, 51, 32, 21, 99, 108, 54, 33 };

    m_sort.BubbleSort(3,a,10);//通过调整第一个参数的值来调用冒泡排序方法中的分支

    for (int i = 0; i < 10; i++)
    {
        cout << a[i] <"pause");
    return EXIT_SUCCESS;
}

在代码中我实现了基础冒泡排序和两种优化的冒泡排序，在主函数中通过传入不同的type值进行调用，注意在使用swap()函数时要包含C++ 的头文件，或者自己实现一个简单的交换即可。

---

总的来说冒泡排序是最基础的排序，要掌握熟练，冒泡排序是稳定排序，平均时间复杂度是O(n2)，适用于数据量较小的情况下