数据结构 — 排序-CSDN博客

本文链接：https://blog.csdn.net/weixin_43876403/article/details/121807518

今天开始复习数据结构，首当其冲的自然是面试必备的八大排序！因为博主之前复习过很多次了，所以这次就直接贴代码了。

插入排序

void insertionSort(){

    for(int i = 1; i < n; ++i){
        int j = i, t = arr[i];
        while(j > 0 && t < arr[j-1]){
            arr[j] = arr[j-1];
            j -= 1;
        }
        arr[j] = t;
    }
}

选择排序

void selectionSort(){

    for(int i = 0; i < n-1; ++i){
        int rec = i;
        for(int j = i+1; j < n; ++j){
            if(arr[j] < arr[rec])
                rec = j;
        }
        if(rec != i)
            swap(arr[rec], arr[i]);
    }
}

冒泡排序

void bubbleSort(){
    bool flag = 1;
    for(int i = 0; flag; ++i){   //表示交换的趟数
        flag = 0;
        for(int j = 0; j < n-i-1; ++j){
            if(arr[j] > arr[j+1]) {
                swap(arr[j], arr[j + 1]);
                flag = 1;
            }
        }
    }
}

快速排序

int partition(int l, int r){
    int x = l;
    for(int i = l; i < r; ++i){
        if(arr[i] < arr[r])
            swap(arr[x++], arr[i]);
    }
    swap(arr[x], arr[r]);
    return x;
}

void quickSort(int l, int r){
    if(l >= r)
        return;
    int x = partition(l, r);
    quickSort(l, x-1);
    quickSort(x+1, r);
}

int main(){
    quickSort(0, n-1);
}

希尔排序

一般选择 $g_{n+1} = 3g_n + 1$ 的 $g a p$ 数列
使用上述 $g a p$ ，希尔排序的时间复杂度基本维持在 $O(n^{1.25})$ 左右

void insertionSort(int g){
    for(int i = g; i < n; ++i){
        int j = i, t = arr[i];
        while(j > 0 && t < arr[j-g]){
            arr[j] = arr[j-g];
            j -= g;
        }
        arr[j] = t;
    }
}

void shellSort(){
    vector<int> gap;
    int g = 1;
    while(g < n) {
        gap.push_back(g);
        g = 3 * g + 1;
    }
    for(int i = gap.size()-1; i >= 0; --i){
        insertionSort(gap[i]);
    }
}

归并排序

归并排序的思想和快排的思想有些类似，区别在于：快排是将数组前后两部分分成大致有序后再进行递归，有自上而下的感觉；而归并则是先不断二分，分到每组只有一个元素后再合并，是自下而上变得有序的过程。

vector<int> L(n), R(n);

void merge(int l, int mid, int r){
    int n1 = mid-l;
    int n2 = r-mid;
    for(int i = 0; i < n1; ++i){
        L[i] = arr[l+i];
    }
    for(int i = 0; i < n2; ++i){
        R[i] = arr[mid+i];
    }

    int i = 0, j = 0;
    L[n1] = R[n2] = INT_MAX;    //  因为L，R中的未填充部分为0，因此需要设置标志位，代表终点

    for(int k = l; k < r; ++k){
        if(L[i] < R[j])
            arr[k] = L[i++];
        else
            arr[k] = R[j++];
    }

}

void mergeSort(int left, int right){    //区间为[left, right)
    if(left+1 < right){
        int mid = (left + right) / 2;
        mergeSort(left, mid);
        mergeSort(mid, right);
        merge(left, mid, right);
    }
}

int main(){
    mergeSort(0, n);
}

计数排序

思想有点类似于逆序对的思想，但是要注意稳定性以及部分细节
仅适用于 $\ge 0$ 的数组排序

void countingSort(int MAX){    // MAX为数组中的最大值
    vector<int> C(MAX+1);

    for(int t : arr){
        C[t] += 1;
    }
    for(int i = 1; i <= MAX; ++i){  //  前缀和计算
        C[i] += C[i-1];
    }
    for(int i = n-1; i >= 0; --i){   // 逆向计算  保证稳定性
        ans[C[arr[i]]] = arr[i];
        C[arr[i]] -= 1;
    }
}