冒泡排序及其优化

  冒泡排序属于交换排序，基本思想：从待排序序列的第2个记录开始，和其前一个相邻的记录进行比较，若发生逆序，则交换。

  冒泡排序的C++实现：

  SortTestHelper.h文件（包含排序的辅助函数）

#include <iostream>
#include <cstdlib>
#include <ctime>  //clock()、CLOCKS_PER_SEC
#include <cassert>  //包含函数assert()

using namespace std;

namespace SortTestHelper
{
    //辅助函数 - 随机产生一个数组
    int* generateRandomArray(int n, int RangeL, int RangeR)  //返回数组首地址
    {
        //判断RangeL是否<=RangeR
        assert(RangeL <= RangeR);  //参数为表达式，表达式为真时返回true，否则打印错误信息

        int *arr = new int[n];
        srand(time(0));
        for(int i = 0; i < n ; i++)
        {
            arr[i] = rand() % (RangeR - RangeL + 1) + RangeL;  //使得产生的随机数在RangeL和RangeR之间
        }
        return arr;
    }

    //辅助函数 - 产生一个近乎有序的随机数组
    int* generateNearlyOrderedArray(int n, int swapTime)
    {
        int *arr = new int[n];
        for(int i = 0; i < n; i++)
        {
            arr[i] = i;  //先生成一个完全有序的数组
        }
        //然后交换几组元素，使之变成无序但近乎有序的数组
        srand(time(0));
        for(int j = 0; j < swapTime; j++)
        {
            //随机生成一个x位置和y位置
            int posx = rand() % n;
            int posy = rand() % n;
            //交换x和y处的元素
            swap(arr[posx], arr[posy]);
        }
        return arr;
    }

    //辅助数组 - 产生一个完全有序数组
    int* generateTotallyOrderedArray(int n)
    {
        int *arr = new int[n];
        for(int i = 0; i < n; i++)
        {
            arr[i] = i;
        }
        return arr;
    }

    //辅助函数 - 打印数组
    template<typename T>
    void printArray(T arr[], int n)
    {
        for(int i = 0; i < n; i++)
        {
            cout << arr[i] << " ";
        }
        cout << endl;
    }

    //辅助函数 - 判断数组是否有序（升序）
    template<typename T>
    bool isSorted(T arr[], int n)
    {
        for(int i = 0; i < n - 1; i++)
        {
            if(arr[i] > arr[i + 1])
            {
                return false;
            }
        }
        return true;
    }

    //辅助函数 - 测试算法的时间
    template<typename T>
    void testSort(string sortname, void(*sort)(T[], int), T arr[], int n)  //arr[]和n是函数指针需要的参数
    {
        clock_t starttime = clock();
        sort(arr, n);  //调用函数sort()
        clock_t endtime = clock();

        //判断排序是否成功
        assert(isSorted(arr, n));  //若是数组无序，则assert会自动调用abort()退出程序，不会执行下面的语句

        cout << sortname << " needs " << double(endtime - starttime) / CLOCKS_PER_SEC << "s." << endl;
    }

    //辅助函数 - 拷贝数组
    int* copyIntArray(int a[], int n)
    {
        int *arr = new int[n];
        //使用C++函数copy()
        copy(a, a + n, arr);
        return arr;
    }
}

main.cpp文件

#include <iostream>
#include "SortTesthHelper.h"
using namespace std;

//冒泡排序
template<typename T>
void BubbleSort(T arr[], int n)
{
    //swaped为true说明本趟排序发生了交换，若swaped为false，说明没有发生交换，则跳出循环
    bool swaped;
    do{
        swaped = false;
        for(int i = 1; i < n; i++)
        {
            if(arr[i] < arr[i - 1])
            {
                swap(arr[i], arr[i - 1]);
                swaped = true;
            }
        }
        // 优化, 每一趟Bubble Sort都将最大的元素放在了最后的位置
        // 所以下一次排序, 最后的元素可以不再考虑
        n--;
    }while(swaped);
}
int main()
{
    //测试
    int n = 100000;
    int *arr =SortTestHelper::generateRandomArray(n, 0, n);
    SortTestHelper::printArray(arr, n);
    SortTestHelper::testSort("Bubble Sort", BubbleSort, arr, n);
    delete[] arr;
    return 0;
}

  冒泡排序的优化：用一个newn变量记录每一轮最后一次交换的位置，下一轮比较到这个位置即可

template<typename T>
void BubbleSort(T arr[], int n)
{
    int newn = 0;
    do{
        for(int i = 1; i < n; i++)
        {
            if(arr[i] < arr[i - 1])
            {
                swap(arr[i], arr[i - 1]);
                newn = i;
            }
        }
        n = newn;
    }while(newn > 0);
}

 优化后的冒泡排序算法时间性能比冒泡排序算法要好。