[算法] O(n^2)算法的效率比较

main.cpp

#include <iostream>
#include "SortTestHelper.h"

using namespace std;

template<typename T>
void selectionSort(T arr[],int n){
    for(int i = 0 ; i < n ; i ++){
        int minIndex = i;
        for( int j = i + 1 ; j < n ; j ++ )
            if( arr[j] < arr[minIndex] )
                minIndex = j;
        swap( arr[i] , arr[minIndex] );
    }    
}

template<typename T>
void insertionSort(T arr[],int n){
    for(int i = 1 ; i < n ; i++ ){
        T e = arr[i];
        int j;
        for(j = i ; j > 0 && arr[j-1] > e ; j --)
            arr[j] = arr[j-1];
        arr[j] = e;
    }
}

int main(){
    int n = 100000;
    int *arr = SortTestHelper::generateNearlyOrderedArray(n,10);

    SortTestHelper::testSort("Insertion Sort",insertionSort,arr,n);
    SortTestHelper::testSort("Selection Sort",selectionSort,arr,n);
    
    delete[] arr;
    return 0;
}

SortTestHelper.h

#include <iostream>
#include <ctime>
#include <cassert>
#include <string>

using namespace std;

namespace SortTestHelper{
    int *generateRandomArray(int n,int rangeL,int rangeR){
        assert(rangeL <= rangeR);
        int *arr = new int[n];
        srand(time(NULL));
        for(int i = 0 ; i < n ; i++)
            arr[i] = rand()%(rangeR-rangeL+1) + rangeL;
        return arr;
    }
    
    int *generateNearlyOrderedArray(int n, int swapTimes){
        int *arr = new int[n];
        for(int i = 0 ; i < n ; i ++ )
            arr[i] = i;
        srand(time(NULL));
        for( int i = 0 ; i < swapTimes ; i ++){
            int posx = rand()%n;
            int posy = rand()%n;
            swap( arr[posx] , arr[posy] );
        }
        return arr;
    }
    
    template<typename T>
    void printArray(T arr[],int n){
        for(int i = 0;i<n;i++)
            cout << arr[i] <<" ";
        cout << endl;
        return;
    }
    
    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(const string &sortName,void (*sort)(T[],int),T arr[],int n){
        
        clock_t startTime = clock();
        sort(arr,n);
        clock_t endTime = clock();
        
        assert(isSorted(arr,n));
        
        cout << sortName << " : " << double(endTime-startTime)/CLOCKS_PER_SEC << " s" <<endl;
        
        return;
    }
}

结果：

插入排序快的原因：

1、可提前终止循环

2、没有交换操作

3、对近乎有序数组，插入排序会更快，甚至快于O(nlogn)级算法，在实际中有大量应用

bubbleSort 方法1

template<typename T>
void bubbleSort( T arr[] , int n){

    bool swapped;

    do{
        swapped = false;
        for( int i = 1 ; i < n ; i ++ )
            if( arr[i-1] > arr[i] ){
                swap( arr[i-1] , arr[i] );
                swapped = true;

            }

        // 优化, 每一趟Bubble Sort都将最大的元素放在了最后的位置
        // 所以下一次排序, 最后的元素可以不再考虑
        n --;

    }while(swapped);
}

bubbleSort 方法2

template<typename T>
void bubbleSort2( T arr[] , int n){

    int newn; // 使用newn进行优化

    do{
        newn = 0;
        for( int i = 1 ; i < n ; i ++ )
            if( arr[i-1] > arr[i] ){
                swap( arr[i-1] , arr[i] );

                // 记录最后一次的交换位置,在此之后的元素在下一轮扫描中均不考虑
                newn = i;
            }
        n = newn;
    }while(newn > 0);
}

bubbleSort的优化：

• 每轮循环如果没有发生交换，就代表数据已经有序，提前退出
• 每轮循环中后面的元素如果已经有序，下一轮循环就不再考虑

三种O(n^2)级别算法的思路：

1、冒泡排序：相邻元素作比较，每次循环后最大的元素放在最后

2、选择排序：找到后面最小的元素，每次循环后最小的元素放在最前

3、插入排序：将新元素插入到有序数组中合适的位置