c++中的快速排序（Quick Sort），归并排序（Merge Sort）和堆排序（Heap Sort）

前言

hello，大家好啊，这里是文宇不是文字，是文宇哦

快速排序（Quick Sort）

快速排序是一种排序算法，通过将一个数组分成两个子数组，再对这两个子数组进行排序，最终将整个数组排序完成。

快速排序的基本思想是：选择一个基准元素（pivot），通过一趟排序将数组分成两部分，使得左边的元素都小于等于基准元素，右边的元素都大于等于基准元素。然后对这两部分分别继续使用同样的方法进行排序，直到整个数组有序。

具体实现过程可以如下：

1. 选择一个基准元素（pivot）。可以选择数组的第一个元素、最后一个元素或者数组中任意一个元素作为基准元素。
2. 设定两个指针（i 和 j），分别指向数组的第一个元素和最后一个元素。
3. 从右向左找到第一个小于等于基准元素的元素，记为 a[j]。
4. 从左向右找到第一个大于等于基准元素的元素，记为 a[i]。
5. 如果 i < j，则交换 a[i] 和 a[j]。
6. 重复步骤3、4、5，直到 i >= j。
7. 将基准元素与 a[j] 交换位置，此时基准元素的位置就是 j。
8. 对基准元素左边的子数组和右边的子数组分别进行递归排序。

下面是一个使用 C++ 实现快速排序的示例代码：

#include <iostream>

using namespace std;

// 交换两个元素的值
void swap(int& a, int& b) {
    int temp = a;
    a = b;
    b = temp;
}

// 快速排序
void quickSort(int arr[], int low, int high) {
    if (low >= high) {
        return;
    }
    
    int pivot = arr[low];  // 选择第一个元素作为基准元素
    int i = low;  // 左指针
    int j = high;  // 右指针
    
    while (i < j) {
        
        // 从右向左找到第一个小于等于基准元素的元素
        while (i < j && arr[j] >= pivot) {
            j--;
        }
        
        // 从左向右找到第一个大于等于基准元素的元素
        while (i < j && arr[i] <= pivot) {
            i++;
        }
        
        // 交换 arr[i] 和 arr[j]
        if (i < j) {
            swap(arr[i], arr[j]);
        }
    }
    
    // 将基准元素与 arr[j] 交换位置
    swap(arr[low], arr[j]);
    
    // 对基准元素左边的子数组进行递归排序
    quickSort(arr, low, j - 1);
    
    // 对基准元素右边的子数组进行递归排序
    quickSort(arr, j + 1, high);
}

int main() {
    int arr[] = {5, 4, 3, 2, 1};
    int n = sizeof(arr) / sizeof(arr[0]);
    
    quickSort(arr, 0, n - 1);
    
    for (int i = 0; i < n; i++) {
        cout << arr[i] << " ";
    }
    cout << endl;
    
    return 0;
}

以上代码实现了快速排序算法，将输入数组按从小到大的顺序排序输出。

归并排序（Merge Sort）

归并排序（Merge Sort）是一种排序算法，它基于分治法（Divide and Conquer）的思想，将一个待排序的数组分成两个子数组，对这两个子数组分别进行归并排序，最后将排序好的两个子数组合并起来，完成整个数组的排序。

归并排序的基本思想是：将待排序的数组不断地二分，直到每个子数组只剩下一个元素。然后将这些单个元素的子数组两两合并，合并后的数组保持有序。重复这个过程，直到最终将整个数组合并成一个有序的数组。

具体实现过程可以如下：

1. 将待排序的数组不断地二分，直到每个子数组只剩下一个元素。
2. 对每一对相邻的子数组进行合并操作，合并后的数组保持有序。合并的过程可以使用一个额外的数组来存储合并的结果，也可以在原数组上进行原地排序。
3. 重复步骤2，直到最终将整个数组合并成一个有序的数组。

下面是一个使用 C++ 实现归并排序的示例代码：

#include <iostream>

using namespace std;

// 合并两个子数组
void merge(int arr[], int left, int mid, int right) {
    int i = left;           // 左子数组的起始索引
    int j = mid + 1;        // 右子数组的起始索引
    int k = 0;              // 临时数组的起始索引
    int* temp = new int[right - left + 1];    // 临时数组
    
    // 比较两个子数组的元素，将较小的元素放入临时数组
    while (i <= mid && j <= right) {
        if (arr[i] <= arr[j]) {
            temp[k++] = arr[i++];
        } else {
            temp[k++] = arr[j++];
        }
    }
    
    // 将剩余的元素放入临时数组
    while (i <= mid) {
        temp[k++] = arr[i++];
    }
    while (j <= right) {
        temp[k++] = arr[j++];
    }
    
    // 将临时数组的元素复制回原数组
    for (int m = 0, n = left; m < k; m++, n++) {
        arr[n] = temp[m];
    }
    
    delete[] temp;
}

// 归并排序
void mergeSort(int arr[], int left, int right) {
    if (left >= right) {
        return;
    }
    
    int mid = (left + right) / 2;   // 数组中间元素的索引
    
    // 对左半部分进行归并排序
    mergeSort(arr, left, mid);
    
    // 对右半部分进行归并排序
    mergeSort(arr, mid + 1, right);
    
    // 合并左右两个子数组
    merge(arr, left, mid, right);
}

int main() {
    int arr[] = {5, 4, 3, 2, 1};
    int n = sizeof(arr) / sizeof(arr[0]);
    
    mergeSort(arr, 0, n - 1);
    
    for (int i = 0; i < n; i++) {
        cout << arr[i] << " ";
    }
    cout << endl;
    
    return 0;
}

以上代码实现了归并排序算法，将输入数组按从小到大的顺序排序输出。在合并两个子数组时，使用了一个临时数组来辅助合并操作。

堆排序（Heap Sort）

堆排序（Heap Sort）是一种排序算法，它是基于二叉堆的数据结构实现的。堆是一个完全二叉树，其中每个父节点的值都大于（或小于）其子节点的值。

堆排序的基本思想是：将待排序的数组构建成一个最大堆（或最小堆），然后将堆顶元素与堆的最后一个元素交换，再将剩余的元素重新调整为最大堆（或最小堆）。重复这个过程，直到整个数组有序。

具体实现过程可以如下：

1. 将待排序的数组构建成一个最大堆（或最小堆）。
2. 将堆顶元素与堆的最后一个元素交换。
3. 将剩余的元素重新调整为最大堆（或最小堆）。
4. 重复步骤2和3，直到整个数组有序。

下面是一个使用 C++ 实现堆排序的示例代码：

#include <iostream>

using namespace std;

// 调整堆，保持堆的性质
void heapify(int arr[], int n, int i) {
    int largest = i;    // 默认最大值索引为 i
    int left = 2 * i + 1;  // 左子节点索引
    int right = 2 * i + 2; // 右子节点索引
    
    // 如果左子节点大于根节点，更新最大值索引
    if (left < n && arr[left] > arr[largest]) {
        largest = left;
    }
    
    // 如果右子节点大于根节点，更新最大值索引
    if (right < n && arr[right] > arr[largest]) {
        largest = right;
    }
    
    // 如果最大值索引不等于 i，交换根节点与最大值节点，并递归调整堆
    if (largest != i) {
        swap(arr[i], arr[largest]);
        heapify(arr, n, largest);
    }
}

// 堆排序
void heapSort(int arr[], int n) {
    // 构建最大堆，从最后一个非叶子节点开始调整堆
    for (int i = n / 2 - 1; i >= 0; i--) {
        heapify(arr, n, i);
    }
    
    // 交换堆顶元素与堆的最后一个元素，并重新调整堆
    for (int i = n - 1; i >= 0; i--) {
        swap(arr[0], arr[i]);
        heapify(arr, i, 0);
    }
}

int main() {
    int arr[] = {5, 4, 3, 2, 1};
    int n = sizeof(arr) / sizeof(arr[0]);
    
    heapSort(arr, n);
    
    for (int i = 0; i < n; i++) {
        cout << arr[i] << " ";
    }
    cout << endl;
    
    return 0;
}

以上代码实现了堆排序算法，将输入数组按从小到大的顺序排序输出。在调整堆的过程中，使用了一个辅助函数 heapify 来保持堆的性质。通过构建最大堆，然后不断地交换堆顶元素与堆的最后一个元素，并重新调整堆，最终实现了堆排序算法。

结语

今天的文章到此结束啦，玛德，快给我干爆了，真不想写