[算法] O(nlogn)和O(n^2)算法性能比较

选择排序、插入排序、归并排序

main.cpp

#include <iostream>
#include "Student.h"
#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;
    }
}

template<typename T>
// 将arr[l...mid]和arr[mid+1...r]两部分进行归并
void __merge(T arr[] , int l, int mid, int r){
    T aux[r-l+1];
    // 将数组复制一份到aux[] 
    for( int i = l ; i <= r ; i ++ )
        aux[i-l] = arr[i];
    // 初始化，i、j指向左、右半部分的起始索引位置 
    int i = l, j = mid + 1;
    for( int k = l ; k <= r ; k ++ ){
        // 如果左半部分已处理完毕 
        if( i > mid){
            arr[k] = aux[j-l];
            j++; 
        }
        // 如果右半部分已处理完毕 
        else if( j > r){
            arr[k] = aux[i-l];
            i ++;
        }
        // 左半部分所指元素 < 右半部分所指元素 
        else if( aux[i-l] < aux[j-l] ){
            arr[k] = aux[i-l];
            i ++;
        }
        // 左半部分所指元素 >= 右半部分所指元素 
        else{
            arr[k] = aux[j-l];
            j++;
        }
    }
}

// 递归使用归并排序，对arr[l...r]的范围进行排序 
template<typename T>
void __mergeSort(T arr[] , int l, int r){
    
    if( l >= r)
        return; 
        
    int mid = (l+r)/2;
    __mergeSort(arr,l,mid);
    __mergeSort(arr,mid+1,r);
    __merge(arr, l, mid, r);     
} 

template<typename T>
void mergeSort(T arr[] , int n){
    __mergeSort( arr , 0 , n-1 );
}

int main(){
    int n = 10000;
    //int *arr = SortTestHelper::generateNearlyOrderedArray(n,10);
    int *arr1 = SortTestHelper::generateRandomArray(n,0,n);
    int *arr2 = SortTestHelper::copyIntArray(arr1, n);
    SortTestHelper::testSort("Insertion Sort",insertionSort,arr1,n);
    SortTestHelper::testSort("Merge Sort",mergeSort,arr2,n);
    
    delete[] arr1;
    delete[] arr2;
    
    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;
    }
    
    // 拷贝整型数组a中所有元素到新数组并返回
    int *copyIntArray(int a[], int n){
        int *arr = new int[n];
        copy(a, a+n, arr);
        return arr;
    } 
    
    // 打印arr数组的所有内容 
    template<typename T>
    void printArray(T arr[],int n){
        for(int i = 0;i<n;i++)
            cout << arr[i] <<" ";
        cout << endl;
        return;
    }
    
    // 判断arr数组是否有序 
    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;
    }
    
    // 测试sort排序算法排序arr数组所得结果的正确性和算法运行时间 
    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;
    }
}

运行结果：

Merge Sort可在1s内轻松处理100万数量级的数据