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

来源：互联网发布：且听风吟朴树知乎编辑：程序博客网时间：2024/05/17 18:12
#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;}
阅读全文
1 0