C/C++实现随机快速排序

快速排序思想

选择数组最后一个位置上的数X
然后把数组根据X进行划分
小于X的放在数组左边
大于X的放在数组右边
然后再对小于等于X的部分进行上述操作
然后再对大于X的部分进行上述操作
时间复杂度O（N*logN）额外空间复杂度O（logN）

相关阅读

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

代码

采用对数器用标准冒泡排序来测试快速排序代码的正确性
排序对数器：
排序对数器

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

inline swap(int arr[], int i, int j){
    int temp = arr[i];
    arr[i] = arr[j];
    arr[j] = temp;
}

inline void outputArr(int arr[], int L, int R){
    for(int i = L; i <= R; i++){
        cout << arr[i] << " ";
    }
    cout << endl;
}

int* partition(int arr[], int L, int R){
    int num = arr[R];
    int less = L-1;
    int more = R;
    int cur = L;
    while(cur < more){
        if(arr[cur] > num){
            swap(arr, --more, cur);
        }else if (arr[cur] < num){
            swap(arr, ++less, cur++);
        }else{
            cur++;
        }
    }
    swap(arr, R, more);
    return new int[2] {less + 1, more};//返回小于部分的最后位置的下一位下标和大于部分的第一位的前一位下标
}

void quickSort(int arr[], int L, int R){
    if(L < R){
        swap(arr, L + rand()%(R-L+1), R);
        int *p = partition(arr, L, R);
        quickSort(arr, L, p[0] - 1);
        quickSort(arr, p[1] + 1, R);
    }
}

int randSize;

//生成随机数组
template <class T>
T* creatArr(int size, int value){
    //srand((unsigned)time(NULL));
    srand(rand());
    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);
        quickSort(b, 0, randSize-1);
        if(!isEqual<int>(a, b, randSize)){
            cout << "Error!" << endl;
            outputArr(a, randSize);
            outputArr(b, randSize);
            break;
        }else{
            outputArr(a, randSize);
            cout << "Nice!" << endl;
        }
    }
    /*int arr[10] = {1,3,5,7,1,2,6,5,4,8};
    quickSort(arr, 0, 9);
    outputArr(arr, 10);*/
}