【C++】C++11 STL算法(五)：设置操作(Set operations)、堆操作(Heap operations)

已于 2023-11-22 20:54:52 修改
阅读量469 收藏
点赞数
分类专栏： C++ 文章标签： c++ 算法 开发语言
于 2019-11-27 17:28:25 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010168781/article/details/103279772
版权

【C++】郭老二博文之：C++目录

设置操作(Set operations)

一、includes
1、原型：
template< class InputIt1, class InputIt2 >
bool includes( InputIt1 first1, InputIt1 last1,
           InputIt2 first2, InputIt2 last2 );
		   
template< class InputIt1, class InputIt2, class Compare >
bool includes( InputIt1 first1, InputIt1 last1,
           InputIt2 first2, InputIt2 last2, Compare comp );
2、说明：

如果一个集合是另一个集合的子集，则返回true

3、官方demo
#include <iostream>
#include <algorithm>
#include <cctype>
#include <vector>
 
int main()
{
  std::vector<char> v1 {'a', 'b', 'c', 'f', 'h', 'x'};
  std::vector<char> v2 {'a', 'b', 'c'};
  std::vector<char> v3 {'a', 'c'};
  std::vector<char> v4 {'g'};
  std::vector<char> v5 {'a', 'c', 'g'};
 
  for (auto i : v1) std::cout << i << ' ';
  std::cout << "\nincludes:\n" << std::boolalpha;
 
  for (auto i : v2) std::cout << i << ' ';
  std::cout << ": " << std::includes(v1.begin(), v1.end(), v2.begin(), v2.end()) << '\n';
  for (auto i : v3) std::cout << i << ' ';
  std::cout << ": " << std::includes(v1.begin(), v1.end(), v3.begin(), v3.end()) << '\n';
  for (auto i : v4) std::cout << i << ' ';
  std::cout << ": " << std::includes(v1.begin(), v1.end(), v4.begin(), v4.end()) << '\n';
  for (auto i : v5) std::cout << i << ' ';
  std::cout << ": " << std::includes(v1.begin(), v1.end(), v5.begin(), v5.end()) << '\n';
 
  auto cmp_nocase = [](char a, char b) {
    return std::tolower(a) < std::tolower(b);
  };
 
  std::vector<char> v6 {'A', 'B', 'C'};
  for (auto i : v6) std::cout << i << ' ';
  std::cout << ": (case-insensitive) "
            << std::includes(v1.begin(), v1.end(), v6.begin(), v6.end(), cmp_nocase)
            << '\n';
}

Output:

a b c f h x
includes:
a b c : true
a c : true
g : false
a c g : false
A B C : (case-insensitive) true
二、set_difference
1、原型：
template< class InputIt1, class InputIt2, class OutputIt >
OutputIt set_difference( InputIt1 first1, InputIt1 last1,
                     InputIt2 first2, InputIt2 last2,
                     OutputIt d_first );
					 
template< class InputIt1, class InputIt2, class OutputIt, class Compare >
OutputIt set_difference( InputIt1 first1, InputIt1 last1,
                     InputIt2 first2, InputIt2 last2,
                     OutputIt d_first, Compare comp );
2、说明：

计算两个集合的差：将[first1,last1)中剔除[first1，last2)的元素，输出到d_first中

3、官方demo
#include <iostream>
#include <algorithm>
#include <vector>
#include <iterator>
 
int main() {
    std::vector<int> v1 {1, 2, 5, 5, 5, 9};
    std::vector<int> v2 {2, 5, 7};
    std::vector<int> diff;
 
    std::set_difference(v1.begin(), v1.end(), v2.begin(), v2.end(), 
                        std::inserter(diff, diff.begin()));
 
    for (auto i : v1) std::cout << i << ' ';
    std::cout << "minus ";
    for (auto i : v2) std::cout << i << ' ';
    std::cout << "is: ";
    for (auto i : diff) std::cout << i << ' ';
    std::cout << '\n';
}

Output:

1 2 5 5 5 9 minus 2 5 7 is: 1 5 5 9
三、set_intersection
1、原型：
template< class InputIt1, class InputIt2, class OutputIt >
OutputIt set_intersection( InputIt1 first1, InputIt1 last1,
                       InputIt2 first2, InputIt2 last2,
                       OutputIt d_first );
					   
template< class InputIt1, class InputIt2, class OutputIt, class Compare >
OutputIt set_intersection( InputIt1 first1, InputIt1 last1,
                       InputIt2 first2, InputIt2 last2,
                       OutputIt d_first, Compare comp );
2、说明：

计算两个集合从交集

3、官方demo
#include <iostream>
#include <vector>
#include <algorithm>
#include <iterator>
int main()
{
    std::vector<int> v1{1,2,3,4,5,6,7,8};
    std::vector<int> v2{5,7,9,10};
    std::sort(v1.begin(), v1.end());
    std::sort(v2.begin(), v2.end());
 
    std::vector<int> v_intersection;
 
    std::set_intersection(v1.begin(), v1.end(),
                          v2.begin(), v2.end(),
                          std::back_inserter(v_intersection));
    for(int n : v_intersection)
        std::cout << n << ' ';
}

Output:

5 7
四、set_symmetric_difference
1、原型：
template< class InputIt1, class InputIt2, class OutputIt >
OutputIt set_symmetric_difference( InputIt1 first1, InputIt1 last1,
                               InputIt2 first2, InputIt2 last2,
                               OutputIt d_first );
							   
template< class InputIt1, class InputIt2, class OutputIt, class Compare >
OutputIt set_symmetric_difference( InputIt1 first1, InputIt1 last1,
                               InputIt2 first2, InputIt2 last2,
                               OutputIt d_first, Compare comp );
2、说明：

计算两个集合之间的对称差：两个集合的并集减去它们的交集

3、官方demo
#include <iostream>
#include <vector>
#include <algorithm>
#include <iterator>
int main()
{
    std::vector<int> v1{1,2,3,4,5,6,7,8     };
    std::vector<int> v2{        5,  7,  9,10};
    std::sort(v1.begin(), v1.end());
    std::sort(v2.begin(), v2.end());
 
    std::vector<int> v_symDifference;
 
    std::set_symmetric_difference(
        v1.begin(), v1.end(),
        v2.begin(), v2.end(),
        std::back_inserter(v_symDifference));
 
    for(int n : v_symDifference)
        std::cout << n << ' ';
}

Output:

1 2 3 4 6 8 9 10
五、set_union
1、原型：
template< class InputIt1, class InputIt2, class OutputIt >
OutputIt set_union( InputIt1 first1, InputIt1 last1,
                InputIt2 first2, InputIt2 last2,
                OutputIt d_first );
				
template< class InputIt1, class InputIt2, class OutputIt, class Compare >
OutputIt set_union( InputIt1 first1, InputIt1 last1,
                InputIt2 first2, InputIt2 last2,
                OutputIt d_first, Compare comp );
2、说明：

计算两个集合的并集

3、官方demo
#include <vector>
#include <iostream>
#include <algorithm>
#include <iterator>
 
int main()
{
    {
        std::vector<int> v1 = {1, 2, 3, 4, 5}; 
        std::vector<int> v2 = {      3, 4, 5, 6, 7}; 
        std::vector<int> dest1;
 
        std::set_union(v1.begin(), v1.end(),
                       v2.begin(), v2.end(),                  
                       std::back_inserter(dest1));
 
        for (const auto &i : dest1) {
            std::cout << i << ' ';
        }   
        std::cout << '\n';
    }
    {
        std::vector<int> v1 = {1, 2, 3, 4, 5, 5, 5}; 
        std::vector<int> v2 = {      3, 4, 5, 6, 7}; 
        std::vector<int> dest1;
 
        std::set_union(v1.begin(), v1.end(),
                       v2.begin(), v2.end(),                  
                       std::back_inserter(dest1));
 
        for (const auto &i : dest1) {
            std::cout << i << ' ';
        }   
        std::cout << '\n';
    }
}

Output:

1 2 3 4 5 6 7 
1 2 3 4 5 5 5 6 7

堆操作（Heap operations）

一、is_heap
1、原型：
template< class RandomIt >
bool is_heap( RandomIt first, RandomIt last );

template< class RandomIt, class Compare >
bool is_heap( RandomIt first, RandomIt last, Compare comp );
2、说明：

判断是否为最大堆：父结点的键值总是大于或等于任何一个子结点的键值时为最大堆

3、官方demo
#include <iostream>
#include <algorithm>
#include <vector>
 
int main()
{
    std::vector<int> v { 3, 1, 4, 1, 5, 9 };
 
    std::cout << "initially, v: ";
    for (auto i : v) std::cout << i << ' ';
    std::cout << '\n';
 
    if (!std::is_heap(v.begin(), v.end())) {
        std::cout << "making heap...\n";
        std::make_heap(v.begin(), v.end());
    }
 
    std::cout << "after make_heap, v: ";
    for (auto i : v) std::cout << i << ' ';
    std::cout << '\n';
}

Output:

initially, v: 3 1 4 1 5 9 
making heap...
after make_heap, v: 9 5 4 1 1 3
二、is_heap_until
1、原型：
template< class RandomIt >
RandomIt is_heap_until( RandomIt first, RandomIt last );

template< class RandomIt, class Compare >
RandomIt is_heap_until( RandomIt first, RandomIt last, Compare comp );
2、说明：

找到从first开始最大范围的最大堆

3、官方demo
#include <iostream>
#include <algorithm>
#include <vector>
 
int main()
{
    std::vector<int> v { 3, 1, 4, 1, 5, 9 };
 
    std::make_heap(v.begin(), v.end());
 
    // 可能把堆搞乱了
    v.push_back(2);
    v.push_back(6);
 
    auto heap_end = std::is_heap_until(v.begin(), v.end());
 
    std::cout << "all of v: ";
    for (auto i : v) std::cout << i << ' ';
    std::cout << '\n';
 
    std::cout << "only heap: ";
    for (auto i = v.begin(); i != heap_end; ++i) std::cout << *i << ' ';
    std::cout << '\n';
}

Output:

all of v:  9 5 4 1 1 3 2 6 
only heap: 9 5 4 1 1 3 2
三、make_heap
1、原型：
template< class RandomIt >
void make_heap( RandomIt first, RandomIt last );
2、说明：

生成堆

3、官方demo
#include <iostream>
#include <algorithm>
#include <functional>
#include <vector>
 
int main()
{
    std::cout << "Max heap:\n";
 
    std::vector<int> v { 3, 2, 4, 1, 5, 9 };	// 最初序列
 
    std::cout << "initially, v: ";
    for (auto i : v) std::cout << i << ' ';
    std::cout << '\n';
 
    std::make_heap(v.begin(), v.end());	// 产生最大堆
 
    std::cout << "after make_heap, v: ";
    for (auto i : v) std::cout << i << ' ';
    std::cout << '\n';
 
    std::pop_heap(v.begin(), v.end());	// 将最大元素移至尾部（待删除）
 
    std::cout << "after pop_heap, v: ";
    for (auto i : v) std::cout << i << ' ';
    std::cout << '\n';
 
    auto top = v.back();
    v.pop_back();	// 删除尾部元素
    std::cout << "former top element: " << top << '\n';
 
    std::cout << "after removing the former top element, v: ";
    for (auto i : v) std::cout << i << ' ';
    std::cout << '\n' << '\n';
 
    std::cout << "Min heap:\n";
 
    std::vector<int> v1 { 3, 2, 4, 1, 5, 9 };
 
    std::cout << "initially, v1: ";
    for (auto i : v1) std::cout << i << ' ';
    std::cout << '\n';
 
    std::make_heap(v1.begin(), v1.end(), std::greater<>{});	// 产生最小堆
 
    std::cout << "after make_heap, v1: ";
    for (auto i : v1) std::cout << i << ' ';
    std::cout << '\n';
 
    std::pop_heap(v1.begin(), v1.end(), std::greater<>{});	// 将最小元素移至尾部（待删除）
 
    std::cout << "after pop_heap, v1: ";
    for (auto i : v1) std::cout << i << ' ';
    std::cout << '\n';
 
    auto top1 = v1.back();
    v1.pop_back();	// 删除尾部数据
    std::cout << "former top element: " << top1 << '\n';
 
    std::cout << "after removing the former top element, v1: ";
    for (auto i : v1) std::cout << i << ' ';
    std::cout << '\n';
}

Output:

Max heap:
initially, v: 3 2 4 1 5 9 
after make_heap, v: 9 5 4 1 2 3 
after pop_heap, v: 5 3 4 1 2 9 
former top element: 9
after removing the former top element, v: 5 3 4 1 2 

Min heap:
initially, v1: 3 2 4 1 5 9 
after make_heap, v1: 1 2 4 3 5 9 
after pop_heap, v1: 2 3 4 9 5 1 
former top element: 1
after removing the former top element, v1: 2 3 4 9 5
四、push_heap
1、原型：
template< class RandomIt >
void push_heap( RandomIt first, RandomIt last );

template< class RandomIt, class Compare >
void push_heap( RandomIt first, RandomIt last, Compare comp );
2、说明：

将位于last-1的元素插入到[first, last-1)中，并保持最大堆。在此之前需要执行push_back将新元素添加到尾部。

3、官方demo
#include <iostream>
#include <algorithm>
#include <vector>
 
int main()
{
    std::vector<int> v { 3, 1, 4, 1, 5, 9 };
 
    std::make_heap(v.begin(), v.end());
 
    std::cout << "v: ";
    for (auto i : v) std::cout << i << ' ';
    std::cout << '\n';
 
    v.push_back(6);
 
    std::cout << "before push_heap: ";
    for (auto i : v) std::cout << i << ' ';
    std::cout << '\n';
 
    std::push_heap(v.begin(), v.end());
 
    std::cout << "after push_heap: ";
    for (auto i : v) std::cout << i << ' ';
    std::cout << '\n';
}

Output:

v: 9 5 4 1 1 3 
before push_heap: 9 5 4 1 1 3 6 
after push_heap:  9 5 6 1 1 3 4
五、pop_heap
1、原型：
template< class RandomIt >
void pop_heap( RandomIt first, RandomIt last );

template< class RandomIt, class Compare >
void pop_heap( RandomIt first, RandomIt last, Compare comp );
2、说明：

交换位于first和last-1的值，然后使子范围[first, last-1)成为堆。
等于把最大堆中第一个元素即最大的值“删除”，这里的删除是加引号，因为没有真正删除。紧接着使用pop_back才能真正删除最大的元素。

3、官方demo
#include <iostream>
#include <algorithm>
#include <vector>
 
int main()
{
    std::vector<int> v { 3, 1, 4, 1, 5, 9 };
 
    std::make_heap(v.begin(), v.end());
 
    std::cout << "v: ";
    for (auto i : v) std::cout << i << ' ';
    std::cout << '\n';
 
    std::pop_heap(v.begin(), v.end()); // 把最大的元素移到最后，此时还没有删除
 
    std::cout << "after pop_heap: ";
    for (auto i : v) std::cout << i << ' ';
    std::cout << '\n';
 
    int largest = v.back();
    v.pop_back();  // 在这里会真正删除最大元素。
    std::cout << "largest element: " << largest << '\n';
 
    std::cout << "heap without largest: ";
    for (auto i : v) std::cout << i << ' ';
    std::cout << '\n';
}

Output:

v: 9 5 4 1 1 3 
after pop_heap: 5 3 4 1 1 9 
largest element: 9
heap without largest: 5 3 4 1 1
六、sort_heap
1、原型：
template< class RandomIt >
void sort_heap( RandomIt first, RandomIt last );

template< class RandomIt, class Compare >
void sort_heap( RandomIt first, RandomIt last, Compare comp );
2、说明：

将最大堆转换成升序排列

3、官方demo
#include <algorithm>
#include <vector>
#include <iostream>
 
int main()
{
    std::vector<int> v = {3, 1, 4, 1, 5, 9}; 
 
    std::make_heap(v.begin(), v.end());
 
    std::cout << "heap:\t";
    for (const auto &i : v) {
        std::cout << i << ' ';
    }   
 
    std::sort_heap(v.begin(), v.end());
 
    std::cout << "\nsorted:\t";
    for (const auto &i : v) {                                                   
        std::cout << i << ' ';
    }   
    std::cout << '\n';
}

Output:

heap:   9 4 5 1 1 3 
sorted: 1 1 3 4 5 9
郭老二
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
stl操作_c++stl操作_
09-28
c++ stl操作常见的函数重载结构体优先队列排序等
C++ STL自带的堆
tankpanv的博客
09-08 5989
一、STL自带堆：priority_queue stack与queue注意事项： 1 stack不允许有遍历行为，stack也不提供迭代器。SGI STL便以deque作为缺省情况下stack底部结构，称之为adapter（配接器） 2 除了deque之外，list也是双向开口的数据结构 3 queue与stack的情况类似，不提供迭代器，也可以以list作为底层容器,默认为deque。 ...
C++ STL容器之heap（堆）篇
Flowing_River的博客
08-12 2662
没有想到第一次用堆 是在LeetCode的算法题上，作为一个学生党来说，需要用到堆跟堆算法的场景确实比较少。 这篇文章不仅是跟大家分享有关于堆的知识，也是为了通过这种方式巩固我自己对堆的理解。并且我将通过最开始说的拿到LeetCode题来跟大家一起实践堆的使用 。 本期文章代码将用C++来进行说明。
C++STL算法之堆算法
最新发布
m0_74228185的博客
07-04 1285
注意：真正意义上的，插入数据和删除数据，还是要根据相应的容器调用其中的函数（比如：push_back,pop_back）堆就是如图，像这样一种连续的数据，但是注意0的位置不存储数据，目的是为了让编号一置。入堆（不是传的数据，只是每一次调用，让你变成堆的形式），起到一个调整数据位置的作用。这个排序默认，也就是简单的从小到大排序，当然第三个参数，你应该也可以写比较准则。出堆的时候，先调用这个函数，将第一个元素，放到最后面，然后用尾删法，删除数据。在插入数据的时候，调用这个函数，将其变为堆的形式。
【C++】STL之heap（堆）
qq_36367326的博客
03-27 2240
转自：https://www.cnblogs.com/MrLiuZF/p/13498631.html 1、误区！ 1、堆排序排完后的堆和大顶堆、小顶堆不是一个概念！ 2、堆分为大顶堆和小顶堆，即要么大顶堆（大根堆/最大堆），要么小顶堆。 3、对于堆，堆的根节点一定是堆中所有节点的最大值或者最小值。 4、大顶堆只是说这个堆总每一个节点满足：每一个节点大于或者等于其左右娃。并非这个堆一定是从大到小的序列。 5、所以才必须要有堆排序呀！堆排序排完了之后的，才一定是一个有序的序列。 6、堆实际上是用数组或者vect
c++中set_difference这个函数的意义和用法
秋月的私语
04-27 2198
今天正好碰到了这个函数，虽然一眼就可以看出这个函数的作用，但是仍然期待一个通俗易懂的解释，网上搜索了一下，搜到百度百科，感觉没有抓住重点，虽然示例也勉强可以理解，但是总感觉讲究不够直观。是C++中的一个函数，它接受两个有序的范围作为输入，并输出在第一个范围中但不在第二个范围中的元素。输出写入到一个第三个范围中，该范围必须足够大以容纳所有输出的元素。于是，最终在Notion的帮助下，我得到了以下回答，我觉得这个讲解很棒，而且示例中很贴心第改变了输出数组的大小。中，并且该函数返回指向输出范围结尾的迭代器。
C++常用stl算法.pdf
11-22
学习c++，stdl 常用的算法方法，比如for_each,bind,等
c++ STL set_difference set_intersection set_union 操作
01-20
以下是STL algorithm的几个函数，使用的条件是有序容器，所以 vector在被sort了之后是可以使用的，set也是可以使用的。 set_difference 这个是求得在第一个容器中有，第二个容器中没有的。set_intersection 求两个...
c++非变易算法-stl算法
12-31
C++ STL标准模板库在数据结构和算法的实践领域发挥着重要作用，极大的提高了开发效率。STL的三大组成部分为容器、迭代器、算法，本文主要讲解STL算法中的非变易算法。本文从实践的角度简单介绍了一下相关函数的使用...
c++11中关于std::thread的join的详解
08-26
主要介绍了c++11中关于std::thread的join详解，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
跟我学c++中级篇——STL算法之堆操作
fpcc的专栏
05-22 2125
一、堆 堆和栈，会不会有人立刻想到这两个数据结构？会不会有人想到OS中的堆和栈？这里的堆，其实指的数据结构的堆并由此实现的堆排序。什么是堆？堆就是一种以序列式集合而形成的二叉树。堆根据实现的情况分为大根（顶）堆，小根（顶）堆，也就是说，根（或父）节点比其孩子节点值大的为大根堆，反之为小根堆。在STL中一般是使用大根堆。 二、STL堆操作 在STL库中，主要的操作有如下几个函数： 值得注意的是，很多的堆操作都放到c++11以后，也就是说，在c++11以前，堆基本是一个幕后英雄。 三、...
聊聊C++11标准库中堆(heap)算法的源码
FlushHip
12-29 1969
STL中支持堆操作，对外暴露了`std::make_heap`，`std::push_heap`，`std::pop_heap`，`std::sort_heap`，`std::is_heap`，`std::is_heap_until`这6个函数，详细的使用方法可以参见[图解STL中算法的分类、简介及其Demo](https://blog.csdn.net/FlushHip/article/details/82858933#t37)。
C++ 学习之集合算法：set_intersection(交集)、set_union(并集)、set_difference(差集)
阿乐的博客
11-05 5860
1、首先介绍一下相关概念 (1) 并集 对于两个给定集合A、B，由两个集合所有元素构成的集合，叫做A和B的并集。 记作：AUB 读作“A并B” 例：{ 3,5 }U{ 2,3,4,6 } = { 2,3,4,5,6 } (2) 交集 对于两个给定集合A、B，由属于A又属于B的所有元素构成的集合，叫做A和B的交集。 记作： A∩B 读作“A交B” 例： A = { 1,2,3,4,5 }，B = { 3,4,5,6,8 }，A∩B = { 3,4,5 } (3) 差集 假设有集合A和B
C++11标准模板（STL）- 算法 - 集合操作（在已排序范围上）（std::set_difference）
qq_40788199的博客
12-03 1238
复制来自已排序范围 [first1, last1) 并且不在已排序范围 [first2, last2) 中找到的元素到始于 d_first 的范围。 1) 用 operator< 比较元素，而范围必须对于相同者排序。 3) 用给定的二元比较函数 comp 比较元素，而范围必须对于相同者排序。
C++STL之堆
mijoe10的博客
09-15 611
C++STL恶心到死，不过学会了就比较便捷,前几天学习了一下C++STL的堆操作，现在来口胡一下^_^first at all: STL堆要用到头文件#include<algorithm>,所以，先把头文件打好吧 下面_first和_last为可以随机访问的迭代器（指针），_comp为比较函数（仿函数），相信大家都明白，但还是啰嗦一下凑字数1.建堆 make_heap(_first,_last
C++11标准模板（STL）- 算法 - 堆操作（std::make_heap）
qq_40788199的博客
12-09 1017
在范围 [first, last) 中构造最大堆。函数第一版本用 operator< 比较元素，第二版本用给定的比较函数 comp 。 first, last - 制作堆来源的元素范围 comp - 比较函数对象（即满足比较 (Compare) 要求的对象），若首个参数小于第二个，则返回 ​true 。
C++11标准模板（STL）- 算法 - 排序操作 （std::partial_sort）
qq_40788199的博客
11-22 822
重排元素，使得范围 [first, middle) 含有范围 [first, last) 中已排序的 middle - first 个最小元素。 不保证保持相等的元素顺序。范围 [middle, last) 中剩余的元素顺序未指定。 1) 用 operator< 比较元素。 3) 用给定的二元比较函数 comp 比较元素。
C++中STL用法超详细总结（收藏级）
qq_40989769的博客
12-09 3306
STL中六大组件：容器（Container），是一种数据结构，如list，vector，和deques ，以模板类的方法提供。为了访问容器中的数据，可以使用由容器类输出的迭代器；迭代器（Iterator），提供了访问容器中对象的方法。例如，可以使用一对迭代器指定list或vector中的一定范围的对象。迭代器就如同一个指针。事实上，C++的指针也是一种迭代器。但是，迭代器也可以是那些定义了operator*()以及其他类似于指针的操作符地方法的类对象；
【C++】 STL详解
热门推荐
m0_56051805的博客
10-01 2万+
【C++】 STL详解
C++11STL中常用堆算法有哪些，请详细介绍
06-03
C++11STL中常用堆算法有以下几个，分别是： 1. make_heap：将一个序列变成一个堆。 2. push_heap：将一个元素插入到堆中，并保持堆的性质。 3. pop_heap：将堆顶元素移到序列末尾，并保持堆的性质。 4. sort_...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

郭老二

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

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

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

打赏作者

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

抵扣说明：

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

余额充值