C++实现冒泡排序以及优化

冒泡排序（Bubble Sort）基本思想：
两两比较相邻记录的关键字，如果反序则交换，直到没有反序的记录为止。
冒泡排序的基本流程：
1.比较相邻的元素，如果前一个比后一个大，就把它们两个调换位置。
2.对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。
3.针对所有的元素重复以上的步骤，除了最后一个。
4.持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
冒泡排序的代码实现：

#include
using namespace std;

void BubbleSort1(int arr[], int length);
void BubbleSort2(int arr[], int length);
void Swap(int arr[], int i, int j);
void ShowResult(int arr[], int length);

int main()
{
    int arr[] = { 9,2,3,3,9,7,5,1,9,2,10 };
    int length = sizeof(arr) / sizeof(int);
    ShowResult(arr, length);
    //BubbleSort1(arr, length);
    BubbleSort2(arr, length);
    ShowResult(arr, length);

    system("pause");
    return 0;
}

void BubbleSort1(int arr[], int length)
{
    if (arr == nullptr || length < 0 || length == 0)
        return;
    for (int i = 0; i < length; i++)
    {
        for (int j = 0; j < length - 1 - i; j++)
        {
            if (arr[j] > arr[j + 1])
                Swap(arr, j, j + 1);
        }
    }
}

void BubbleSort2(int arr[], int length)
{
    if (arr == nullptr || length < 0 || length == 0)
        return;
    bool flag = true;
    for (int i = 0; i < length && flag; i++)
    {
        flag = false;
        for (int j = 0; j < length - 1 - i; j++)
        {
            if (arr[j] > arr[j + 1])
            {
                Swap(arr, j, j + 1);
                flag = true;
            }
        }
    }
}

void Swap(int arr[], int i, int j)
{
    int temp = arr[i];
    arr[i] = arr[j];
    arr[j] = temp;
}

void ShowResult(int arr[], int length)
{
    for (int i = 0; i < length; i++)
        cout << arr[i] << "\t";
    cout << endl;
}

输出的结果为：

其中，BubbleSort2是对BubbleSort1的改进，假如我们待排序的序列为{2，1，3，4，5，6，7，8，9}，也就是说除了第一个和第二个关键字需要交换外，其余均是正常的顺序。当i=0时，交换了2和1，此时的序列已经有序，但算法仍然将i=1到i=8以及每个循环中的j都循环了一遍，尽管没有交换顺序，但是之后的大量比较还是大大地多余，所以我们通过一个标志位来判断后面的饿序列是否已经有序。
冒泡排序的时间复杂度分析:
最好情况时（即序列已经有序），从我们改进的算法中可以分析出，只需要 n−1 n − 1 次比较，所以时间复杂度为 O(n) O ( n ) ，最坏情况时（序列是逆序），需要比较的次数为 (n−1)+(n−2)+...+2+1=n(n−1)2 ( n − 1 ) + ( n − 2 ) + . . . + 2 + 1 = n ( n − 1 ) 2 ，并做等数量级的记录移动，所以总的时间复杂度为 O(n2) O ( n 2 ) .