排序对数器

介绍

通过一种保证正确的简单算法来验证另外一种高效的算法是否正确
文中使用冒泡排序来验证编写的归并排序是否正确
如果归并排序结果出错会输出Error!，并且输出两个数组便于比较
如果归并排序结果正确则会输出Nice!

相关阅读

堆排序
冒泡排序
选择排序
插入排序
归并排序
随机快速排序
一维随机数组生成器

完整代码

#include <bits/stdc++.h>
using namespace std;
int randSize;

//生成随机数组
template <class T>
T* creatArr(int size, int value){
    srand((unsigned)time(NULL));
    randSize = rand()%(size+1)+1;
    T *arr = new T [randSize];
    for(int i = 0; i < randSize; i++){
        arr[i] = rand()%(value+1) - rand()%(value+1);
        cout << arr[i] << " ";
    }
    cout << endl;
    return arr;
}

//输出数组
template<class T>
void outputArr(T arr[], int size){
    for(int i = 0; i < size; i++){
        cout << arr[i] << " ";
    }
    cout << endl;
}

//拷贝数组
template<class T>
T* copyArr(T arr[], int size){
    T* newArr = new T [size];
    for(int i = 0; i < size; i++){
        newArr[i] = arr[i];
    }
    return newArr;
}

//冒泡排序
template <class T>
void bubbleSort(T arr[], int size){
    for(int end = size -1; end > 0; end--){
        for(int i = 0; i < end; i++){
            if(arr[i] > arr[i+1]){
                T temp = arr[i];
                arr[i] = arr[i+1];
                arr[i+1] = temp;
            }
        }
    }
}

//插入排序
template <class T>
void insertSort(T arr[], int size){
    for(int i = 0; i < size; i++){
        for(int j = i-1; j>=0 && arr[j]>arr[j+1]; j--){
            T temp = arr[j+1];
            arr[j+1] = arr[j];
            arr[j] = temp;
        }
    }
}

//数组判等
template <class T>
bool isEqual(T a[], T b[], int size){
    for(int i = 0; i < size; i++){
        if(a[i] != b[i])
            return false;
    }
    return true;
}


template <class T>
 void merge(T arr[], int L, int mid, int R){
    int size = R-L+1;
    T *helpArr = new T [size];
    int p1 = L;
    int p2 = mid+1;
    int i = 0;
    while(p1<=mid && p2<=R){
        helpArr[i++] = arr[p1]<arr[p2] ? arr[p1++]:arr[p2++];
    }
    while(p1<=mid){
        helpArr[i++] = arr[p1++];
    }
    while(p2<=R){
        helpArr[i++] = arr[p2++];
    }
    for(i = 0; i < size; i++){
        arr[L+i] = helpArr[i];
    }
 }

 template <class T>
 void sortProcess(T arr[], int L, int R){
    if(L==R)
        return;
    int mid = (L+R)/2;
    sortProcess(arr, L, mid);
    sortProcess(arr, mid+1, R);
    merge(arr, L, mid, R);
 }

 //归并排序
 template <class T>
 void mergeSort(T arr[], int size){
    sortProcess(arr, 0, size-1);
 }

int main(){
    int testTime = 50000;
    int size = 10, value = 1000;
    while(testTime--){
        int *arr = creatArr<int>(size, value);
        cout << randSize << endl;
        outputArr(arr, randSize);
        int *a = copyArr(arr, randSize);
        int *b = copyArr(arr, randSize);
        bubbleSort(a, randSize);
        mergeSort(b, randSize);
        if(!isEqual<int>(a, b, randSize)){
            cout << "Error!" << endl;
            outputArr(a, randSize);
            outputArr(b, randSize);
            break;
        }else{
            outputArr(a, randSize);
            cout << "Nice!" << endl;
        }
    }
}