排序之堆排序

堆排序：

性质：

堆排序是一种基于比较的排序算法，它使用二叉堆数据结构来实现。二叉堆是一种特殊的完全二叉树，它满足以下两个性质：

1. 结构性：完全二叉树，即除了最后一层外，其他各层的节点数都达到最大，并且最后一层的节点尽可能地集中在左侧。
2. 堆属性：可以是最大堆或最小堆。在最大堆中，父节点的值总是大于或等于其子节点的值；在最小堆中，父节点的值总是小于或等于其子节点的值。

堆排序步骤：

堆排序的步骤可以分为两个主要部分：

1. 构建堆（Build Heap）
将一个无序的数组转换成堆结构。这个过程从最后一个非叶子节点开始，向上逐个节点进行下沉（Sift Down）操作，直到达到根节点。下沉操作的目的是确保当前节点满足堆属性。

2. 堆排序操作（Heap Sort Operation）
一旦构建了堆，就可以进行排序操作。这个过程包括以下步骤：

• 将堆顶元素（最大或最小元素，取决于是最大堆还是最小堆）与最后一个元素交换。
• 移除最后一个元素，因为已经排序完成。
• 对剩下的元素重新进行下沉操作，以维持堆结构。 

这个过程重复进行，直到堆中只剩下一个元素，此时整个数组就已经被排序完成。

---

堆排序的实现细节：

• 下沉操作（Sift Down）：确保某个节点的值大于其子节点的值（对于最大堆）。如果当前节点的值小于其子节点，就与较大的子节点交换，然后继续这个过程，直到当前节点的值大于其子节点，或者成为叶子节点。

// 辅助函数，用于下沉堆中的一个节点
void siftDown(std::vector<int>& arr, int start, int end) {
    int root = start;
    while ((root * 2 + 1) <= end) { // 有左子节点
        int child = root * 2 + 1; // 左子节点索引
        if (child < end && arr[child] < arr[child + 1]) {
            child++; // 右子节点更大
        }
        if (arr[root] < arr[child]) {
            std::swap(arr[root], arr[child]);
            root = child; // 继续下沉
        } else {
            break;
        }
    }
}

• 构建堆：从最后一个非叶子节点开始，向上逐个节点进行下沉操作。

// 构建堆
void buildHeap(std::vector<int>& arr) {
    for (int i = arr.size() / 2 - 1; i >= 0; --i) {
        siftDown(arr, i, arr.size() - 1);
    }
}

• 排序：交换堆顶元素与最后一个元素，然后对剩下的元素进行下沉操作，直到堆为空。

// 堆排序
void heapSort(std::vector<int>& arr) {
    buildHeap(arr); // 构建堆
    for (int i = arr.size() - 1; i > 0; --i) {
        std::swap(arr[0], arr[i]); // 交换堆顶元素和最后一个元素
        siftDown(arr, 0, i - 1); // 重新下沉堆顶元素
    }
}

---

堆排序的优缺点：

1.优点：

• 原地排序：不需要额外的存储空间。
• 时间复杂度：O(n log n)，对于所有输入都是线性对数级的。

2.缺点：

• 不稳定：相同的元素在排序后可能会改变原来的顺序。
• 空间复杂度：虽然原地排序，但递归实现需要一定的栈空间。

堆排序是一种非常实用的排序算法，尤其适用于数据量大且对稳定性要求不高的场景。由于其高效的性能和简单的实现，它在实际应用中非常受欢迎。

---

实现代码： 

堆排序（Heap Sort）是一种高效的排序算法，它利用了二叉堆的数据结构特性。堆排序可以分为两个主要步骤：构建堆（Build Heap）和堆排序操作（Heap Sort Operation）。以下是使用C++实现堆排序的示例代码：

#include <iostream>
#include <vector>
#include <algorithm> // 包含std::sort

// 辅助函数，用于下沉堆中的一个节点
void siftDown(std::vector<int>& arr, int start, int end) {
    int root = start;
    while ((root * 2 + 1) <= end) { // 有左子节点
        int child = root * 2 + 1; // 左子节点索引
        if (child < end && arr[child] < arr[child + 1]) {
            child++; // 右子节点更大
        }
        if (arr[root] < arr[child]) {
            std::swap(arr[root], arr[child]);
            root = child; // 继续下沉
        } else {
            break;
        }
    }
}

// 构建堆
void buildHeap(std::vector<int>& arr) {
    for (int i = arr.size() / 2 - 1; i >= 0; --i) {
        siftDown(arr, i, arr.size() - 1);
    }
}

// 堆排序
void heapSort(std::vector<int>& arr) {
    buildHeap(arr); // 构建堆
    for (int i = arr.size() - 1; i > 0; --i) {
        std::swap(arr[0], arr[i]); // 交换堆顶元素和最后一个元素
        siftDown(arr, 0, i - 1); // 重新下沉堆顶元素
    }
}

int main() {
    std::vector<int> arr = {5, 3, 17, 10, 84, 19, 6, 22, 9};
    std::cout << "Original array:\n";
    for (int num : arr) {
        std::cout << num << " ";
    }
    std::cout << "\n";

    heapSort(arr); // 执行堆排序

    std::cout << "Sorted array:\n";
    for (int num : arr) {
        std::cout << num << " ";
    }
    std::cout << std::endl;

    return 0;
}

这段代码首先定义了一个siftDown函数，它用于将堆中的一个节点下沉到合适的位置，以保持堆的性质。接着定义了buildHeap函数，它用于将一个数组转换成一个堆。最后，heapSort函数使用这两个辅助函数来对数组进行排序。

堆排序的时间复杂度是O(n*log n)，其中n是数组中元素的数量。堆排序是原地排序算法，不需要额外的存储空间。