1. 大根堆(Max-Heap)

大根堆是一种完全二叉树,满足每个节点的值都不小于其子节点的值,因此,堆顶元素是整个堆的最大值。大根堆常用于实现优先队列,当需要频繁地取最大值时非常有用。

C++ 中的 priority_queue 实现大根堆:

在 C++ 中,priority_queue 默认就是大根堆,因此可以直接使用。

#include <iostream>
#include <queue>
#include <vector>

int main() {
    std::priority_queue<int> maxHeap;

    // 插入元素
    maxHeap.push(10);
    maxHeap.push(5);
    maxHeap.push(20);
    maxHeap.push(1);

    // 输出大根堆元素
    while (!maxHeap.empty()) {
        std::cout << maxHeap.top() << " ";  // 打印堆顶元素
        maxHeap.pop();  // 删除堆顶元素
    }

    return 0;
}
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
  • 14.
  • 15.
  • 16.
  • 17.
  • 18.
  • 19.
  • 20.
  • 21.

输出:

20 10 5 1
  • 1.
2. 从小到大的排序(Ascending Order)

从小到大的排序是将一组元素按照非递减的顺序排列。大多数排序算法默认就是从小到大排序,比如 std::sort

C++ 中的 std::sort 实现从小到大排序:
#include <iostream>
#include <algorithm>
#include <vector>

int main() {
    std::vector<int> vec = {10, 5, 20, 1};

    // 从小到大排序
    std::sort(vec.begin(), vec.end());

    // 输出排序后的元素
    for (int num : vec) {
        std::cout << num << " ";
    }

    return 0;
}
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
  • 14.
  • 15.
  • 16.
  • 17.

输出:

1 5 10 20
  • 1.
3. 小根堆(Min-Heap)

小根堆是一种完全二叉树,满足每个节点的值都不大于其子节点的值,因此,堆顶元素是整个堆的最小值。小根堆常用于需要频繁取最小值的场景。

C++ 中的 priority_queue 实现小根堆:

通过传入比较器 std::greater<int>,可以将 priority_queue 转换为小根堆。

#include <iostream>
#include <queue>
#include <vector>

int main() {
    // 使用 greater<int> 比较器来创建小根堆
    std::priority_queue<int, std::vector<int>, std::greater<int>> minHeap;

    // 插入元素
    minHeap.push(10);
    minHeap.push(5);
    minHeap.push(20);
    minHeap.push(1);

    // 输出小根堆元素
    while (!minHeap.empty()) {
        std::cout << minHeap.top() << " ";  // 打印堆顶元素
        minHeap.pop();  // 删除堆顶元素
    }

    return 0;
}
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
  • 14.
  • 15.
  • 16.
  • 17.
  • 18.
  • 19.
  • 20.
  • 21.
  • 22.

输出:

1 5 10 20
  • 1.
4. 从大到小的排序(Descending Order)

从大到小的排序是将一组元素按照非递增的顺序排列。这可以通过 std::sort 配合 std::greater<int> 比较器来实现。

C++ 中的 std::sort 实现从大到小排序:
#include <iostream>
#include <algorithm>
#include <vector>

int main() {
    std::vector<int> vec = {10, 5, 20, 1};

    // 从大到小排序
    std::sort(vec.begin(), vec.end(), std::greater<int>());

    // 输出排序后的元素
    for (int num : vec) {
        std::cout << num << " ";
    }

    return 0;
}
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
  • 14.
  • 15.
  • 16.
  • 17.

输出:

20 10 5 1
  • 1.
总结
  • 大根堆(Max-Heap):堆顶是最大元素。用于频繁取最大值的场景,如优先队列。
  • 从小到大的排序(Ascending Order):将元素按从小到大的顺序排列,常见排序算法默认都是这个顺序。
  • 小根堆(Min-Heap):堆顶是最小元素。用于频繁取最小值的场景,如优先队列。
  • 从大到小的排序(Descending Order):将元素按从大到小的顺序排列,可以通过改变排序算法的比较器来实现。