2023-03-14 排序算法-分治策略-归并排序和快速排序

摘要:

虽然是关于归并排序和快速排序的分析，但是这两个在思想上有共通之处.

那便是归并排序和快速排序都使用了分治的思想, 并且在代码实现上也都采用了递归.

分治思想是非常经典的思想, 将大问题不断分解成小的问题, 然后进行解决。

归并排序:

1. 对于分治, 是采取了先局部, 后整体的策略
2. 先确保每个分割后的部分被排序, 然后将两个排序后的集合, 合并成新的集合
3. 先对局部进行处理, 再进行整体的处理, 这比较复合写代码时候的分层实现时候先实现下层再实现上层的思路

#include <iostream>
using namespace std;

void merge(int arr[], int l, int m, int r) {
    int n1 = m - l + 1;
    int n2 = r - m;
 
    // 创建临时数组来存储左右子数组中的元素
    int L[n1], R[n2];
    for (int i = 0; i < n1; i++) {
        L[i] = arr[l + i];
    }
    for (int j = 0; j < n2; j++) {
        R[j] = arr[m + 1 + j];
    }
    
    // 将左右子数组合并到原始数组中
    int i = 0, j = 0, k = l;
    while (i < n1 && j < n2) {
        if (L[i] <= R[j]) {
            arr[k] = L[i];
            i++;
        } else {
            arr[k] = R[j];
            j++;
        }
        k++;
    }
    
    // 处理剩下没被合并的元素
    while (i < n1) {
        arr[k] = L[i];
        i++;
        k++;
    }
    while (j < n2) {
        arr[k] = R[j];
        j++;
        k++;
    }
}
 
void mergeSort(int arr[], int l, int r) {
    if (l >= r) {
        return;
    }
    int m = l + (r - l) / 2;
    mergeSort(arr, l, m);
    mergeSort(arr, m + 1, r);
    merge(arr, l, m, r);
}

int main() {
    int arr[] = {10, 7, 8, 9, 1, 5};
    int n = sizeof(arr) / sizeof(arr[0]);
    
    cout << "before: ";
    for (int i = 0; i < n; i++) {
        cout << arr[i] << " ";
    }
    cout << endl;
    
    mergeSort(arr, 0, n - 1);
    
    cout << "over: ";
    for (int i = 0; i < n; i++) {
        cout << arr[i] << " ";
    }
    cout << endl;
    
    return 0;
}

快速排序:

1. 可以看作是先整体, 再局部
2. 先对集合的整体, 分割成一小一大两部分
3. 然后再将两个集合，继续分割成一小一大的部分
4. 这是从顶层开始向下思考, 比较复合做架构设计时的从整体到局部的思想

#include <iostream>

using namespace std;

void quickSort(int arr[], int left, int right) {
    int i = left;
    int j = right;
    int tmp;
    int pivot = arr[(left + right) / 2];

    /* partition */
    while (i <= j) {
        while (arr[i] < pivot)
            i++;
        while (arr[j] > pivot)
            j--;
        if (i <= j) {
            tmp = arr[i];
            arr[i] = arr[j];
            arr[j] = tmp;
            i++;
            j--;
        }
    };

    /* recursion */
    if (left < j)
        quickSort(arr, left, j);
    if (i < right)
        quickSort(arr, i, right);
}

int main() {
    int arr[] = { 81, 78, 22, 13, 47, 99, 34, 21 };
    int n = sizeof(arr)/sizeof(arr[0]);
    quickSort(arr, 0, n-1);
    cout << "Sorted array: \n";
    for (int i=0; i < n; i++)
        cout << arr[i] << " ";
    return 0;
}