排序模板（自用）

/*
** Copyright (C) QPSOFT.COM All rights reserved.
*/

#ifndef SORT_H
#define SORT_H

class Sort {
private:
    int* arr;
    int arrLen;
private:
    /** 快排随机选取枢轴 */
    int SelectPivotRandom(int low, int high);
    /** 快排递归 */
    void quickSort(int begin, int end);
    /** 归并递归 */
    void mergeSort(int* tmp, int begin, int end);
    /** 堆调整 */
    void HeapAdjust(int begin, int end);
public:
    Sort(int * arr, int len);
    ~Sort();
    void insertSort();
    void selectSort();
    void bubbleSort();
    void quickSort();
    void shellSort();
    void heapSort();
    void mergeSort();
    void output();
};
#endif // SORT_H

/*
** Copyright (C) QPSOFT.COM All rights reserved.
*/

#include "sort.h"
#include <stdio.h>
#include <algorithm>
#include <time.h>
using namespace std;
// public
Sort::Sort(int * a, int len) {
    arr = new int[len+1];
    for (int i = 0; i < len; i++) {
        this->arr[i] = a[i];
    }
    arrLen = len;
}

Sort::~Sort() {
    delete []arr;
    arr = NULL;
}

void Sort::output() {
    for (int i = 0; i < arrLen; i ++) {
        printf("%d ", arr[i]);
    }
    printf("\n");
}

void Sort::insertSort() {
    for (int i = 1; i < arrLen; i ++) {
        for (int j = i - 1; j >= 0 && arr[j] > arr[j+1]; j --) {
            swap(arr[j], arr[j+1]);
        }
    }
}

void Sort::bubbleSort() {
    bool exchange = true;
    for (int i = 1; i < arrLen && exchange; i ++) {
        exchange = false;
        for (int j = 0; j < arrLen - i; j ++) {
            if(arr[j] > arr[j+1]) {
                swap(arr[j+1], arr[j]);
                exchange = true;
            }
        }
    }
}

void Sort::selectSort() {
    for (int i = 0; i < arrLen; i++) {
        int minNum = 1 << 31 - 1, ind = i;
        for (int j = i; j < arrLen; j ++) {
            if(minNum > arr[j]) {
                minNum = arr[j];
                ind = j;
            }
        }
        swap(arr[i], arr[ind]);
    }
}

void Sort::quickSort() {
    quickSort(0, arrLen-1);
}

void Sort::mergeSort() {
    int *tmp = new int[arrLen + 1];
    mergeSort(tmp, 0, arrLen-1);
    delete []tmp;
}

void Sort::shellSort() {
    for (int delta = arrLen / 2; delta > 0; delta /= 2) {
        for (int i = delta; i < arrLen; i ++) {
            for (int j = i - delta; j >= 0 && arr[j] > arr[j+delta]; j -= delta) {
                swap(arr[j], arr[j+delta]);
            }
        }
    }
}

void Sort::heapSort() {
    //堆化数组
    for (int i = arrLen/2 - 1; i >= 0; i--) {
        HeapAdjust(i, arrLen-1);
    }
    for(int i = arrLen - 1; i > 0; i --) {
        swap(arr[0], arr[i]);
        HeapAdjust(0, i - 1);
    }
}

void Sort::HeapAdjust(int begin, int end) {
    int j = 2 * begin + 1;
    while(j <= end) {
        // 选择孩子节点中较大的。
        if(j < end && arr[j] < arr[j+1]) {
            j ++;
        }
        if(arr[j] < arr[begin]) {
            break;
        }
        swap(arr[begin], arr[j]);
        begin = j;
        j = 2 * begin + 1;
    }
}

// private
void Sort::quickSort(int begin, int end) {
    if(begin >= end) {
        return ;
    }
    int i = begin, j = end;
//    int pivot = arr[begin];
    int pivot = SelectPivotRandom(begin, end);
    while (i < j) {
        while (j > i && arr[j] > pivot) {
            j --;
        }
        if(i < j) {
            arr[i ++] = arr[j];
        }
        while (i < j && arr[i] < pivot ) {
            i ++;
        }
        if(i < j) {
            arr[j --] = arr[i];
        }
    }
    arr[i] = pivot;
    quickSort(begin, i-1);
    quickSort(i+1, end);
}

int Sort::SelectPivotRandom(int low, int high)
{
    //产生枢轴的位置
    srand((unsigned)time(NULL));
    int pivotPos = rand() % (high - low) + low;

    //把枢轴位置的元素和low位置元素互换，此时可以和普通的快排一样调用划分函数
    swap(arr[pivotPos], arr[low]);
    return arr[low];
}

void Sort::mergeSort(int *tmp, int begin, int end) {
    if(begin >= end) {
        return ;
    }
    int mid = (begin + end) >> 1;
    mergeSort(tmp, begin, mid);
    mergeSort(tmp, mid+1, end);
    int i = begin, j = mid + 1;
    int k = begin;
    while (i <= mid && j <= end) {
        if (arr[i] <= arr[j]) {
            tmp[k++] = arr[i++];
        }
        if (arr[i] > arr[j]) {
            tmp[k++] = arr[j++];
        }
    }
    while (i <= mid) {
        tmp[k++] = arr[i++];
    }
    while (j <= end) {
        tmp[k++] = arr[j++];
    }
    for (int i = begin; i <= end; i ++) {
        arr[i] = tmp[i];
    }
}