【day-16】C++各种排序

#include <iostream>
#include <vector>

using namespace std;

/*
TODO:直接插入排序
 时间复杂度O(n^2)
    最好情况：有序,O(n)
    最差情况：到序,O(n^2)
 空间复杂度O(1)
 稳定性 稳定
 */
vector<int> straightInsertionSort(vector<int> array) {
    int size = array.size();
    for (int i = 1; i < size; i++) {
        int j = i - 1;
        int temp = array[i];
        while (j >= 0 && array[j] > temp) {
            array[j + 1] = array[j];
            j--;
        }
        array[j + 1] = temp;
    }
    return array;
}

/*
TODO:希尔排序
  时间复杂度 与希尔增量有关系
 空间复杂度O(1)
 稳定性 不稳定
 */
vector<int> shellSort(vector<int> array) {
    int size = array.size();
    int step = size / 2;
    while (step > 0) {
        for (int i = step; i < size; i++) {
            int j = i - step;
            int temp = array[i];
            while (j >= 0 && array[j] > temp) {
                array[j + step] = array[j];
                j = j - step;
            }
            array[j + step] = temp;
        }
        step = step / 2;
    }
    return array;
}

/*
TODO:简单选择排序
 时间复杂度O(n^2)
    最好情况：有序,O(n^2)
    最差情况：到序,O(n^2)
 空间复杂度O(1)
 稳定性 不稳定
 */
vector<int> selectSort(vector<int> array) {
    int size = array.size();
    for (int i = 0; i < size; i++) {
        int k = i;
        for (int j = i + 1; j < size; j++) {
            if (array[j] < array[k]) {
                k = j;
            }
        }
        if (k != i) {
            swap(array[i], array[k]);
        }
    }
    return array;
}

/*
TODO:堆排序
 时间复杂度O(nlgn)
    最好情况：O(nlgn)
    最差情况：O(nlgn)
 空间复杂度O(1)
 稳定性 不稳定
 */
void heapBuild(vector<int> &array, int root, int size) {
    int l = 2 * root + 1;
    int m = l;
    if (l < size) {
        int r = l + 1;
        if (r < size && array[r] > array[l]) {
            m = r;
        }
        if (array[m] > array[root]) {
            swap(array[m], array[root]);
            heapBuild(array, m, size);
        }
    }
}

vector<int> heapSort(vector<int> array) {
    int size = array.size();
    for (int i = size / 2 - 1; i >= 0; i--) {
        heapBuild(array, i, size);
    }
    for (int last = size - 1; last > 0; last--) {
        swap(array[0], array[last]);
        heapBuild(array, 0, last);
    }
    return array;
}

/*
TODO:冒泡排序
 时间复杂度O(n^2)
    最好情况：有序,O(n)
    最差情况：到序,O(n^2)
 空间复杂度O(1)
 稳定性 稳定
 */
vector<int> bubbleSort(vector<int> array) {
    int size = array.size();
    for (int i = 0; i < size - 1; i++) {
        bool exchangeFlag = false;
        for (int j = 0; j < size - 1 - i; j++) {
            if (array[j] > array[j + 1]) {
                swap(array[j], array[j + 1]);
                exchangeFlag= true;
            }
        }
        if(!exchangeFlag){
            break;
        }
    }
    return array;
}

/*
TODO:快速排序
 时间复杂度O(n*logn)
    最好情况：划分得很均匀,O(n*logn)
    最差情况：当待排序的序列为正序或逆序排列时，且每次划分只得到一个比上一次划分少一个记录的子序列，注意另一个为空,O(n^2)
 空间复杂度O(1)
 稳定性 稳定
 */
void quickSort(vector<int> &array, int start, int end) {
    if (start >= end) {
        return;
    }
    int first = start;
    int last = end;
    int key = array[first];
    while (last > first) {
        while (last > first && array[last] >= key) {
            last--;
        }
        array[first] = array[last];
        while (last > first && array[first] <= key) {
            first++;
        }
        array[last] = array[first];
    }
    array[first] = key;
    quickSort(array, start, first - 1);
    quickSort(array, first + 1, end);
    return;
}

/*
TODO:归并排序
 时间复杂度O(nlogn)
    最好情况：O(nlogn)
    最差情况：O(nlogn)
 空间复杂度O(n)
 稳定性 稳定
 */
void merge(vector<int> &array, vector<int> &arrayTemp, int start, int mid, int end) {
    int i = start;
    int j = mid + 1;
    int k = start;
    while (i <= mid && j <= end) {
        if (array[i] < array[j]) {
            arrayTemp[k++] = array[i++];
        } else {
            arrayTemp[k++] = array[j++];
        }
    }
    while (i <= mid)arrayTemp[k++] = array[i++];
    while (j <= end)arrayTemp[k++] = array[j++];
    for (int i = start; i <= end; i++) {
        array[i] = arrayTemp[i];
    }
}

void mergeSort(vector<int> &array, vector<int> &arrayTemp, int start, int end) {
    if (end > start) {
        int mid = (start + end) / 2;
        mergeSort(array, arrayTemp, start, mid);
        mergeSort(array, arrayTemp, mid + 1, end);
        merge(array, arrayTemp, start, mid, end);
    }
}

/*
TODO:基数排序
 稳定性 稳定
 r:关键字的基数，d代表长度，n代表关键字的个数
 */
int maxNumOfDigital(vector<int> array) {
    int size = array.size();
    int num = 1;
    int radix = 10;
    for (int i = 0; i < size; i++) {
        while (array[i] >= radix) {
            radix *= 10;
            num++;
        }
    }
    return num;
}

void radixSort(vector<int> &array) {
    int size = array.size();
    int num = maxNumOfDigital(array);
    vector<int> temp(size), bucket(10);
    int radix = 1;
    for (int i = 0; i <num; i++) {
        for (int j = 0; j < 10; j++) {
            bucket[j] = 0;
        }
        for (int j = 0; j < size; j++) {
            int k = (array[j] / radix) % 10;
            bucket[k]++;
        }
        for (int j = 1; j < 10; j++) {
            bucket[j] = bucket[j] + bucket[j - 1];
        }
        //TODO:一定要是倒过来装进去！！！
        for (int j = size-1; j >= 0; j--) {
            int k = (array[j] / radix) % 10;
            temp[bucket[k] - 1] = array[j];
            bucket[k]--;
        }
        for (int j = 0; j < size; j++) {
            array[j] = temp[j];
        }
        radix *= 10;
    }
}

void print(string str, vector<int> input) {
    cout << str << ":";
    for (auto it = input.begin(); it != input.end(); it++) {
        cout << *it << " ";
    }
    cout << endl;
}

int main() {
    vector<int> array{22, 44, 33, 1, 44, 3, 100, 11, 33};
    vector<int> res;

    res = straightInsertionSort(array);
    print("直接插入", res);

    res = shellSort(array);
    print("希尔排序", res);

    res = selectSort(array);
    print("选择排序", res);

    res = heapSort(array);
    print("堆 排 序", res);

    res = bubbleSort(array);
    print("冒泡排序", res);

    vector<int> arrayTemp = array;
    quickSort(arrayTemp, 0, arrayTemp.size() - 1);
    print("快速排序", res);

    arrayTemp = array;
    vector<int> arrayTemp2(array.size());
    mergeSort(arrayTemp, arrayTemp2, 0, arrayTemp.size() - 1);
    print("归并排序", res);

    arrayTemp = array;
    radixSort(arrayTemp);
    print("基数排序", arrayTemp);

    return 0;
}