【C++之泛型算法】016Heap算法

最新推荐文章于 2024-07-24 14:54:00 发布
最新推荐文章于 2024-07-24 14:54:00 发布
阅读量798 收藏 9
点赞数 33
分类专栏： C++ 文章标签： 算法 c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/d710055071/article/details/137734098
版权

文章目录

make_heap()

make_heap 是 C++ 标准库 中提供的一个函数，用于将一个给定的范围（例如数组或向量）转换为一个堆（heap）。特别地，它通常用于创建最大堆。
泛型声明

make_heap 的泛型声明如下：

template< class RandomIt >
void make_heap( RandomIt first, RandomIt last );

template< class RandomIt, class Compare >
void make_heap( RandomIt first, RandomIt last, Compare comp );

其中：

  • RandomIt 是一个随机访问迭代器类型，用于指定输入范围的开始和结束。
  • first 和 last 分别指向输入范围的开始和结束。
  • Compare 是一个可选的比较函数或函数对象，用于定义堆的排序规则。如果未提供，则使用 < 操作符进行默认比较。

具体用法

下面是一个简单的例子，展示如何使用 make_heap：

#include <iostream>
#include <vector>
#include <algorithm>

int main() {
    // 创建一个向量
    std::vector<int> v = {4, 1, 3, 9, 7, 2, 8, 5, 6};

    // 使用 make_heap 将向量转换为最大堆
    std::make_heap(v.begin(), v.end());

    // 输出堆中的元素
    for (const auto& num : v) {
        std::cout << num << " ";
    }
    std::cout << std::endl;

    return 0;
}

在这个例子中，make_heap 将向量 v 转换为一个最大堆。因此，堆顶元素（即向量中的第一个元素）将是最大的元素。

如果你想使用自定义的比较函数来定义堆的排序规则，可以这样做：

#include <iostream>
#include <vector>
#include <algorithm>

// 自定义比较函数
bool my_compare(int a, int b) {
    return a < b; // 这将创建一个最小堆
}

int main() {
    std::vector<int> v = {4, 1, 3, 9, 7, 2, 8, 5, 6};

    // 使用自定义比较函数将向量转换为最小堆
    std::make_heap(v.begin(), v.end(), my_compare);

    // 输出堆中的元素
    for (const auto& num : v) {
        std::cout << num << " ";
    }
    std::cout << std::endl;

    return 0;
}

在这个例子中，make_heap 使用 my_compare 函数来创建一个最小堆。

push_heap()

push_heap 是 C++ 标准库 中提供的一个函数，用于将一个元素插入到已有的堆中，并重新调整堆以保持其性质。如果堆是使用 make_heap 创建的，则可以使用 push_heap 来在堆的末尾添加新元素，并确保堆的性质得到维护。
泛型声明

push_heap 的泛型声明如下：

template< class RandomIt >
void push_heap( RandomIt first, RandomIt last );

template< class RandomIt, class Compare >
void push_heap( RandomIt first, RandomIt last, Compare comp );

其中：

  • RandomIt 是一个随机访问迭代器类型，用于指定堆的范围。
  • first 和 last 分别指向堆的范围的开始和结束。
  • Compare 是一个可选的比较函数或函数对象，用于定义堆的排序规则。如果未提供，则使用 < 操作符进行默认比较。

具体用法

下面是一个使用 push_heap 的例子：

#include <iostream>
#include <vector>
#include <algorithm>

int main() {
    // 创建一个向量并转换为最大堆
    std::vector<int> v = {4, 1, 3, 9, 7, 2, 8, 5, 6};
    std::make_heap(v.begin(), v.end());

    // 输出初始堆中的元素
    std::cout << "Initial heap: ";
    for (const auto& num : v) {
        std::cout << num << " ";
    }
    std::cout << std::endl;

    // 在堆的末尾插入一个新元素
    v.push_back(10);
    std::push_heap(v.begin(), v.end());

    // 输出更新后堆中的元素
    std::cout << "Heap after pushing 10: ";
    for (const auto& num : v) {
        std::cout << num << " ";
    }
    std::cout << std::endl;

    return 0;
}

在这个例子中，我们首先使用 make_heap 将向量 v 转换为一个最大堆。然后，我们在向量的末尾添加一个新元素 10，并使用 push_heap 来重新调整堆，确保堆的性质得到维护。因此，新元素 10 会被放置在正确的位置上，以保持堆是一个最大堆。

如果你想要使用自定义的比较函数来定义堆的排序规则，你可以像下面这样做：

#include <iostream>
#include <vector>
#include <algorithm>

// 自定义比较函数
bool my_compare(int a, int b) {
    return a < b; // 这将创建一个最小堆
}

int main() {
    std::vector<int> v = {4, 1, 3, 9, 7, 2, 8, 5, 6};

    // 使用自定义比较函数创建最小堆
    std::make_heap(v.begin(), v.end(), my_compare);

    // 在堆的末尾插入一个新元素并重新调整堆
    v.push_back(10);
    std::push_heap(v.begin(), v.end(), my_compare);

    // 输出更新后堆中的元素
    for (const auto& num : v) {
        std::cout << num << " ";
    }
    std::cout << std::endl;

    return 0;
}

在这个例子中，push_heap 使用 my_compare 函数来确保堆保持最小堆的性质。

pop_heap()

pop_heap 是 C++ 标准库 中提供的一个函数，用于从堆中移除并返回堆顶元素（即最大或最小元素，取决于堆的性质），然后重新调整堆以保持其性质。如果堆是使用 make_heap 创建的，则可以使用 pop_heap 来移除堆顶元素，并确保剩余的堆元素仍然保持堆的性质。
泛型声明

pop_heap 的泛型声明如下：

template< class RandomIt >
void pop_heap( RandomIt first, RandomIt last );

template< class RandomIt, class Compare >
void pop_heap( RandomIt first, RandomIt last, Compare comp );

其中：

  • RandomIt 是一个随机访问迭代器类型，用于指定堆的范围。
  • first 和 last 分别指向堆的范围的开始和结束。
  • Compare 是一个可选的比较函数或函数对象，用于定义堆的排序规则。如果未提供，则使用 < 操作符进行默认比较。

具体用法

下面是一个使用 pop_heap 的例子：

#include <iostream>
#include <vector>
#include <algorithm>

int main() {
    // 创建一个向量并转换为最大堆
    std::vector<int> v = {4, 1, 3, 9, 7, 2, 8, 5, 6};
    std::make_heap(v.begin(), v.end());

    // 输出初始堆中的元素
    std::cout << "Initial heap: ";
    for (const auto& num : v) {
        std::cout << num << " ";
    }
    std::cout << std::endl;

    // 移除并返回堆顶元素（最大元素）
    int top_element = std::pop_heap(v.begin(), v.end());
    std::cout << "Removed top element: " << top_element << std::endl;

    // 输出移除堆顶元素后的堆
    std::cout << "Heap after popping top element: ";
    for (const auto& num : v) {
        std::cout << num << " ";
    }
    std::cout << std::endl;

    return 0;
}

在这个例子中，我们首先使用 make_heap 将向量 v 转换为一个最大堆。然后，我们使用 pop_heap 来移除并返回堆顶元素（即最大元素），并将剩余的堆元素重新调整为最大堆。因此，pop_heap 之后，堆顶元素（即向量中的第一个元素）将是剩余元素中的最大元素。

如果你想使用自定义的比较函数来定义堆的排序规则，可以像下面这样做：

#include <iostream>
#include <vector>
#include <algorithm>

// 自定义比较函数
bool my_compare(int a, int b) {
    return a < b; // 这将创建一个最小堆
}

int main() {
    std::vector<int> v = {4, 1, 3, 9, 7, 2, 8, 5, 6};

    // 使用自定义比较函数创建最小堆
    std::make_heap(v.begin(), v.end(), my_compare);

    // 输出初始堆中的元素
    for (const auto& num : v) {
        std::cout << num << " ";
    }
    std::cout << std::endl;

    // 移除并返回堆顶元素（最小元素）
    int top_element = std::pop_heap(v.begin(), v.end(), my_compare);
    std::cout << "Removed top element: " << top_element << std::endl;

    // 输出移除堆顶元素后的堆
    for (const auto& num : v) {
        std::cout << num << " ";
    }
    std::cout << std::endl;

    return 0;
}

在这个例子中，pop_heap 使用 my_compare 函数来确保堆保持最小堆的性质，并移除并返回最小的元素。

sort_heap()

sort_heap 是 C++ 标准库 中提供的一个函数，用于将堆（heap）中的元素进行排序。堆是一种特殊的完全二叉树结构，通常使用数组来表示，其中每个父节点的值都大于或等于（对于最大堆）或小于或等于（对于最小堆）其子节点的值。sort_heap 函数会利用堆的性质，以线性时间复杂度将堆中的元素转换为有序序列。
泛型声明

sort_heap 的泛型声明如下：

template< class RandomIt >
void sort_heap( RandomIt first, RandomIt last );

template< class RandomIt, class Compare >
void sort_heap( RandomIt first, RandomIt last, Compare comp );

其中：

  • RandomIt 是一个随机访问迭代器类型，用于指定堆的范围。
  • first 和 last 分别指向堆的范围的开始和结束。
  • Compare 是一个可选的比较函数或函数对象，用于定义堆的排序规则。如果未提供，则使用 < 操作符进行默认比较。

具体用法

下面是一个使用 sort_heap 的例子：

#include <iostream>
#include <vector>
#include <algorithm>

int main() {
    // 创建一个向量并转换为最大堆
    std::vector<int> v = {4, 1, 3, 9, 7, 2, 8, 5, 6};
    std::make_heap(v.begin(), v.end());

    // 输出初始堆中的元素
    std::cout << "Initial heap: ";
    for (const auto& num : v) {
        std::cout << num << " ";
    }
    std::cout << std::endl;

    // 将堆排序
    std::sort_heap(v.begin(), v.end());

    // 输出排序后的堆（现在是一个有序序列）
    std::cout << "Sorted heap: ";
    for (const auto& num : v) {
        std::cout << num << " ";
    }
    std::cout << std::endl;

    return 0;
}

在这个例子中，我们首先使用 make_heap 将向量 v 转换为一个最大堆。然后，我们使用 sort_heap 对堆进行排序，使其成为一个有序序列。sort_heap 会保持堆的性质直到整个序列都变得有序，因此它可以在 O(N) 的时间复杂度内完成排序，其中 N 是堆中元素的数量。排序后，堆中的元素将以升序排列（对于默认的比较操作 <）。

如果你想要使用自定义的比较函数来定义排序规则，可以像下面这样做：

#include <iostream>
#include <vector>
#include <algorithm>

// 自定义比较函数
bool my_compare(int a, int b) {
    return a < b; // 这将创建一个最小堆，并且排序后也是升序排列
}

int main() {
    std::vector<int> v = {4, 1, 3, 9, 7, 2, 8, 5, 6};

    // 使用自定义比较函数创建最大堆
    std::make_heap(v.begin(), v.end(), my_compare);

    // 输出初始堆中的元素
    for (const auto& num : v) {
        std::cout << num << " ";
    }
    std::cout << std::endl;

    // 将堆排序
    std::sort_heap(v.begin(), v.end(), my_compare);

    // 输出排序后的堆
    for (const auto& num : v) {
        std::cout << num << " ";
    }
    std::cout << std::endl;

    return 0;
}

在这个例子中，我们使用了自定义的比较函数 my_compare 来创建一个最小堆，并且排序后也是升序排列。如果你想要降序排列，你可以在比较函数中交换 a 和 b 的位置。

熊猫Devin
关注
  • 33
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
a*算法 c语言,C++算法之A*算法
weixin_32008105的博客
05-22 754
在前面的博客当中，其实我们已经讨论过寻路的算法。不过，当时的示例图中，可选的路径是唯一的。我们挑选一个算法，就是说要把这个唯一的路径选出来，怎么 选呢？当时我们就是采用穷尽递归的算法。然而，今天的情形有点不太一样了。在什么地方呢？那就是今天的路径有n条，这条路径都可以达到目的地，然而我们在 挑选的过程中有一个要求，那就是挑选的路径距离最短？有没有什么办法呢？ 那么，这时候就要A*算法就可以排上...
C++算法程序整理——递归算法
sunqin的博客
02-08 2710
递归算法 递归，定义一个过程或函数时出现调用本过程或本函数的成分，称之为递归。 一般来说，能够用递归解决的问题应该满足以下三个条件： 1）需要解决的问题可以转化为一个或多个同构（或同样性质的）子问题来求解，而这些子问题的求解方法与原问题完全相同，只是在数量规模上不同。 2）递归调用的次数必须是有限的。 3）必须有结束递归的条件来终止递归。 ...
C++11标准模板（STL）- 算法 - 堆操作（std::make_heap）
qq_40788199的博客
12-09 1086
在范围 [first, last) 中构造最大堆。函数第一版本用 operator< 比较元素，第二版本用给定的比较函数 comp 。 first, last - 制作堆来源的元素范围 comp - 比较函数对象（即满足比较 (Compare) 要求的对象），若首个参数小于第二个，则返回 ​true 。
C++ make_heap等堆函数的使用
sinat_31608641的博客
11-16 2706
二叉堆算法
C++语法——make_heap、push_heap、pop_heap、sort_heap使用介绍
weixin_61857742的博客
11-15 3176
这个函数用于建立堆。前两个参数为迭代器类型，最后一个为仿函数，用于确定建堆方式。默认使用大堆排序。可以调用官方仿函数greater，构建小堆排序，也可以自定义仿函数给参数comp。使用方式如下：这个用于将堆底数据加入堆结构中。因为nake_heap只能建堆，如果当前堆数据发生改变，就需要使用push_heap重回大堆/小堆。值得注意：first-last之间的元素必须满足堆结构。它仅仅是将last之后元素插入堆中。意思就是，如果一次性插入多个元素，它只会把最后一个元素（堆底）加入堆结构中
make_heap(), pop_heap(), push_heap()用法
热门推荐
liu_sheng_1991的博客
08-24 1万+
对make_heap(), pop_heap(), push_heap()的用法做个总结： make_heap()生成堆，他有两个参数，也可以有三个参数，前两个参数是指向开始元素的迭代器和指向结束元素的下一个元素的迭代器。第三个参数是可选的，可以用伪函数less()和greater()来生成大顶堆和小顶堆，其中type为元素类型。如果只传入前两个参数，默认是生成大顶堆。 push_heap()是
【C++】STL中heap函数的用法(make_heap，push_heap，pop_heap，sort_heap，is_heap，is_heap_until)
bandaoyu的note
11-02 4367
简介 make_heap()将区间内的元素转化为heap. push_heap()对heap增加一个元素. pop_heap()对heap取出下一个元素. sort_heap()对heap转化为一个已排序群集. 用法 template<typename T> inline void INSERT_ELEMENTS(T &coll, int first, int last) { for (int i = first; i <= last; ++i) .
C++中两种实现堆的方式:make_heap和priority_queue
simple_lxs的博客
08-05 519
C++中两种实现堆的方式:make_heap和priority_queue
Algorithm:算法研究
03-25
2. 强大的类型系统：C++的模板机制允许我们编写泛型代码，适用于不同数据类型的算法。 3. 内存管理：C++提供了指针，允许直接访问内存，实现底层优化，如快速数组操作和自定义数据结构。 4. 性能优化：C++支持inline...
visual C++ 算法排序系统
03-29
在这个项目中，开发者可能使用了模板来实现排序算法的泛型化，使得算法能处理不同类型的数据，如整数、浮点数甚至是自定义对象。 通过这个项目，学习者可以深入了解C++的模板机制以及不同排序算法的工作原理和性能...
像计算机科学家一样思考c++
08-15
指针是C++的强项之一，它允许直接操作内存，但同时也增加了程序出错的可能性，因此需要谨慎使用。 在实际编程中，设计模式（design pattern）是解决常见问题的成熟方案，如工厂模式、单例模式、观察者模式等。理解...
面试总结资料.docx
04-13
C 的基础上增加了类，C 程序的设计首要考虑的是如何通过一个过程，对输入（或环境条件）进行运算处理得到输出（或实现过程（事务）控制），而 C++ 首要考虑的是如何构造一个对象模型，让这个模型能够契合与之对应的...
C++ ——一文读懂：make_heap(), pop_heap(), push_heap()用法
xiaohu的博客
12-19 2688
make_heap()是生成一个堆，大顶堆或小顶堆 make_heap(_RAIter,_RAIter) //默认生成大顶堆 //_Compare有两种参数，一种是greater（生成小顶堆），一种是less（生成大顶堆） make_heap(_RAIter,_RAIter,_Compare) push_heap()是向堆中插入一个元素，并且使堆的规则依然成立 //默认为大顶堆 push_he...
STL algorithm算法make_heap和sort_heap(32)
roaylchen的博客
09-17 1万+
make_heap原型： std::make_heap default (1) template void make_heap (RandomAccessIterator first, RandomAccessIterator last); custom (2) template void make_heap (Rando
heap算法函数—make_heap、push_heap、pop_heap和sort_heap
qq_39014877的博客
02-29 1519
C++的STL提供了make_heap、push_heap、pop_heap、sort_heap等算法，它们用来将一个随机存储的数组或者容器等转换为一个heap。这里所说的转换为heap意思是将原来的存储顺序改变，将转换成的堆层序遍历后所得到的元素顺序作为数组或者容器新的元素顺序(实质上就是对原来的数据用一个算法换了一下元素顺序)。 1、make_heap() 函数声明： template &lt...
C++ 堆 STL函数make_heap, pop_heap, push_heap, sort_heap
weixin_43250478的博客
03-25 434
C++中堆make_heap, pop_heap, push_heap, sort_heap的应用： 函数说明： std::make_heap将[start, end)范围进行堆排序，默认使用less, 即最大元素放在第一个。 std::pop_heap将front（即第一个最大元素）移动到end的前部，同时将剩下的元素重新构造成(堆排序)一个新的heap。 std::push_heap对刚...
Heap算法详解
Keep Moving~
07-06 3511
本文主要介绍了STL中四种heap算法，包括make_heap(), sort_heap(),pop_heap(),push_heap()
C++_数据结构_堆用法详解
惊鸿一博
12-20 1715
1. 基本概念 堆（heaps）是一种特殊的数据组织方式，STL中的 priority_queue 容器适配器底层就是采用堆来组织数据存储的。为了弄明白堆是什么，首先要搞清楚什么是树存储结构。 1.1 树存储结构 树是分层排列的元素或节点。每个节点有一个键，它是节点中所保存的对象，就如同链表中的节点。父节点是有一个或两个子节点的节点。一般父节点可以有任意个数的子节点，树中的父节点不需要有相同个数的子节点。没有子节点的节点叫作叶节点。一般父节点的键与其子节点有一些关系。树都有一个根节点，它是树的基础，.
代码随想录算法训练营第22天-leetcode-二叉树08：669. 修剪二叉搜索树；108.将有序数组转换为二叉搜索树；538.把二叉搜索树转换为累加树
最新发布
weixin_65180740的博客
07-24 849
你可能需要改变树的根节点，所以结果应当返回修剪好的二叉搜索树的新的根节点。给出二叉 搜索 树的根节点，该树的节点值各不相同，请你将其转换为累加树（Greater Sum Tree），使每个节点 node 的新值等于原树中大于或等于 node.val 的值之和。题目要求，实际上是每个节点加上中序排列后面的那个节点，故而可以反向中序排序，即RNL，用prior记录前一个节点的值，加上前一个节点的值即可。左右子树也必须是二叉搜索树。后序遍历每个节点，对于在范围外的节点，考虑保留其左子树/右子树（只可能保留一个）
STL源码探索：C++泛型编程深度剖析
书中详细剖析了SGI STL（Stanford University的Standard Generic Library）的源代码，这是C++社区广泛使用的STL实现之一。通过阅读和理解SGI STL的源码，读者可以了解到以下关键知识点： 1. 容器（Containers）： ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

熊猫Devin

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值