【STL常用算法库及常用容器】

已于 2024-09-27 16:45:28 修改
阅读量862 收藏 10
点赞数 20
分类专栏： C++笔记 个人笔记 文章标签： 算法 c++
于 2024-09-23 11:48:22 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gxf_1999/article/details/141327215
版权

写在前面

本篇内容为学习记录用，如有错误欢迎批评指正

STL常用算法

通用打印数据

我自己方便打印后续打印调用写的

void print_int_one(int val)
{
    std::cout << val << ' ';
}

遍历算法

1、遍历元素：遍历容器中每个元素，并进行相关操作：
函数原型：for_each(iterator begin,iterator end)

// 遍历算法 for_each(iterator begin,iterator end,),遍历容器中的元素；
// parameter‌ : begin-开始迭代器   end-结束迭代器   _func-仿函数，用于指定将遍历的元素进行何种操作
void for_each_test()
{
    std::vector<int> m_vector;
    for (int i = 0; i < 10; ++i) {
        m_vector.emplace_back(i * i);
    }

    std::for_each(m_vector.begin(), m_vector.end(), print_int_one); //打印每个元素
    std::cout << std::endl;
}

2、搬运元素：将原容器的元素搬运至目标容器
函数原型：transform(iterator begin_1,iterator end_1,iterator begin_2,_func)

// 遍历算法 transform(iterator begin_1,iterator end_1,iterator begin_2,_func)，将源容器的内容搬运到目标容器中；
// parameter‌ : begin_1-源容器的开始迭代器   end_1-源容器的结束迭代器   begin_2-目标容器的开始迭代器
// parameter : _func 在搬运容器时，对搬运容器内的元素进行操作
void transform_test()
{
    std::vector<int> m_source;
    for (int i = 0; i < 10; ++i) {
        m_source.emplace_back(i * i);
    }
    std::vector<int> m_target;
    m_target.resize(m_source.size());

    std::transform(m_source.begin(), m_source.end(), m_target.begin(), [](int val) { return val * 2; }); //元素乘2后放入新容器中
    std::for_each(m_target.begin(), m_target.end(), print_int_one);
    std::cout << std::endl;
}

查找算法

1、一般查找，找到指定值在容器内的位置
函数原型：find(iterator begin,iterator end ,value)

//查找算法 find(iterator begin,iterator end ,value) 查找容器中每个元素，找到则返回第一次出现的迭代器，反之返回结束迭代器
// parameter‌ : begin-开始迭代器   end-结束迭代器   value-查找的元素
void find_test()
{
    std::vector<int> m_source;
    for (int i = 0; i < 10; ++i) {
        m_source.emplace_back(i * i);
    }

    std::vector<int>::iterator pit = std::find(m_source.begin(), m_source.end(), 4); //查找元素为4
    if (pit == m_source.end())
        std::cout << "no find val" << std::endl;
    else
        std::cout << "find val:" << *pit << std::endl;
}

2、条件查找：根据条件在容器内查找元素位置
函数原型：find_if(iterator begin,iterator end ,_pred)

// 查找算法 find_if(iterator begin,iterator end ,_pred) 条件查找容器中每个元素，找到满足_pred函数条件的首个迭代器
// parameter‌ : begin-开始迭代器   end-结束迭代器   _pred-bool类型的仿函数
void find_if_test()
{
    std::vector<int> m_source;
    for (int i = 0; i < 10; ++i) {
        m_source.emplace_back(i * i);
    }

    std::vector<int>::iterator pit = std::find_if(m_source.begin(), m_source.end(), [](int val) { return val > 16; }); //查找比16大的元素
    if (pit == m_source.end())
        std::cout << "no find val" << std::endl;
    else
        std::cout << "find val:" << *pit << std::endl;
}

3、查找相邻重复元素
函数原型：adjacent_find(iterator begin,iterator end )

// 查找算法 adjacent_find(iterator begin,iterator end ) 查找容器中相邻重复元素，找到则返回相邻元素的第一个位置，反之返回结束迭代器
// parameter‌ : begin-开始迭代器   end-结束迭代器
void adjacent_find_test()
{
    std::vector<int> m_source{1, 2, 3, 4, 4, 5, 7, 8, 9, 9};

    std::vector<int>::iterator pit = std::adjacent_find(m_source.begin(), m_source.end());
    if (pit == m_source.end())
        std::cout << "no find Same element" << std::endl;
    else
        std::cout << "Same element:" << *pit << std::endl;
}

4、二分查找指定元素，前提是容器是有序的
函数原型：binary_search(iterator begin,iterator end ,value)

// 查找算法 binary_search(iterator begin,iterator end ,value) 二分查找容器内是否存在指定元素,返回true或false
// parameter‌ : begin-开始迭代器   end-结束迭代器 value-要查找的值
// note:前提是容器是有序的
void binary_search_test()
{
    std::vector<int> m_source;
    for (int i = 0; i < 10; ++i) {
        m_source.emplace_back(i * i);
    }
    bool ret = std::binary_search(m_source.begin(), m_source.end(), 4); //查找元素为4
    if (ret)
        std::cout << " find value" << std::endl;
    else
        std::cout << " no find value" << std::endl;
}

5、统计次数：统计元素在容器中出现的次数
函数原型：count(iterator begin,iterator end ,value)

// 查找算法 count(iterator begin,iterator end ,value) 统计元素在容器中出现的次数
// parameter‌ : begin-开始迭代器   end-结束迭代器 value-要查找的值
void count_test()
{
    std::vector<int> m_source{1, 2, 3, 4, 6, 5, 4, 5, 6, 4, 3, 5};
    int ret = std::count(m_source.begin(), m_source.end(), 5); //统计元素5出现的次数
    std::cout << " Repetitions:" << ret << std::endl;
}

6、条件统计：按条件统计元素在容器中出现的次数
函数原型：count_if(iterator begin,iterator end ,_pred)

// 查找算法 count_if(iterator begin,iterator end ,_pred) 按条件统计元素在容器中出现的次数
// parameter‌ : begin-开始迭代器   end-结束迭代器 _pred-bool类型的仿函数
void count_if_test()
{
    std::vector<int> m_source;
    for (int i = 0; i < 10; ++i) {
        m_source.emplace_back(i * i);
    }

    int ret = std::count_if(m_source.begin(), m_source.end(), [](int val) { return val > 10; }); //统计元素大于10出现的次数
    std::cout << " Repetitions:" << ret << std::endl;
}

7、查找插入元素不影响容器有序性的位置
注意：容器必须为有序序列

//查找算法 lower_bound(iterator begin,iterator end,value)返回插入元素不影响有序性的第一个位置
//查找算法 upper_bound(iterator begin,iterator end,value)返回插入元素不影响有序性的最后一个位置
//查找算法 equal_range(iterator begin,iterator end,value)返回插入元素不影响有序性的第一个和最后一个位置
// parameter‌ : begin-开始迭代器   end-结束迭代器   value-查找值
//note:容器有序
void equal_range_test()
{
    std::vector<int> m_source{1, 1, 3, 4, 5, 6, 7, 6, 8, 6, 9, 5};
    std::for_each(m_source.begin(), m_source.end(), print_int_one);
    std::cout << std::endl;

    auto m_result1 = std::lower_bound(m_source.begin(), m_source.end(), 5); //返回插入元素不影响有序性的第一个位置
    if (m_result1 == m_source.end())
        std::cout << "no find val" << std::endl;
    else
        std::cout << *m_result1 << std::endl;

    auto m_result2 = std::upper_bound(m_source.begin(), m_source.end(), 5); //返回插入元素不影响有序性的最后一个位置
    if (m_result2 == m_source.end())
        std::cout << "no find val" << std::endl;
    else
        std::cout << *m_result2 << std::endl;

    auto m_result3 = std::equal_range(m_source.begin(), m_source.end(), 5); //返回插入元素不影响有序性的第一个和最后一个位置
    if (m_result3.first == m_result3.second)
        std::cout << "no find val" << std::endl;
    else
        std::cout << *m_result3.first << ' ' << *m_result3.second << std::endl;
}

排序算法

1、sort快排：
函数原型：sort(iterator begin,iterator end ,_pred)

// 排序算法 sort(iterator begin,iterator end ,_pred) 对容器元素进行排序
// parameter‌ : begin-开始迭代器   end-结束迭代器 _pred-bool类型的仿函数，排序标准
void sort_test()
{
    std::vector<int> m_source{2, 34, 53, 4, 54, 23, 21};
    std::sort(m_source.begin(), m_source.end(), [](int a, int b) { return a < b; }); //升序排序
    std::for_each(m_source.begin(), m_source.end(), print_int_one);
    std::cout << std::endl;
    std::sort(m_source.begin(), m_source.end(), [](int a, int b) { return a > b; }); //降序排序
    std::for_each(m_source.begin(), m_source.end(), print_int_one);
    std::cout << std::endl;
}

2、洗牌算法：将容器内的随机打乱，也称洗牌算法
函数原型：shuffle(iterator begin,iterator end)

// 洗牌算法 shuffle(iterator begin,iterator end)将容器内的随机打乱，也称洗牌算法
// parameter‌ : begin-开始迭代器   end-结束迭代器
void shuffle_test()
{
    std::vector<int> m_source{1, 2, 3, 4, 5, 6, 7};
    std::random_device rd;
    std::mt19937 generator(rd());
    std::shuffle(m_source.begin(), m_source.end(), generator);
    std::for_each(m_source.begin(), m_source.end(), print_int_one);
    std::cout << std::endl;
}

3、合并算法：将两个有序容器的元素合并到新的容器内
函数原型：merge(iterator beg1,iterator end1,iterator beg2,iterator end2,iterator dest)

// 合并算法 merge(iterator beg1,iterator end1,iterator beg2,iterator end2,iterator dest)将两个有序容器的元素合并到新的容器内
// parameter‌ : beg1-开始迭代器1   end1-结束迭代器1   beg2-开始迭代器2   end2-结束迭代器2  dest-目标容器
// note:两个源容器必须有序，且排序一致
void merge_test()
{
    std::vector<int> m_source1;
    std::vector<int> m_source2;
    for (int i = 0; i < 10; ++i) {
        m_source1.emplace_back(std::rand() % 100 + 5);
        m_source2.emplace_back(std::rand() % 100 + 5);
    }
    std::sort(m_source1.begin(), m_source1.end(), [](int a, int b) { return a < b; }); //升序
    std::sort(m_source2.begin(), m_source2.end(), [](int a, int b) { return a < b; }); //升序
    std::vector<int> m_dest;
    m_dest.resize(m_source1.size() * 2);
    std::merge(m_source1.begin(), m_source1.end(), m_source2.begin(), m_source2.end(), m_dest.begin());
    std::for_each(m_source1.begin(), m_source1.end(), print_int_one);
    std::cout << std::endl;
    std::for_each(m_source2.begin(), m_source2.end(), print_int_one);
    std::cout << std::endl;
    std::for_each(m_dest.begin(), m_dest.end(), print_int_one);
    std::cout << std::endl;
}

4、反转算法：将容器内的元素进行反转
函数原型：reverse(iterator begin,iterator end)

// 反转算法 reverse(iterator begin,iterator end)将容器内的元素进行反转
// parameter‌ : begin-开始迭代器   end-结束迭代器
void reverse_test()
{
    std::vector<int> m_source{1, 2, 3, 4, 5, 5, 6, 7, 7, 2, 12};
    std::for_each(m_source.begin(), m_source.end(), print_int_one);
    std::cout << std::endl;
    std::reverse(m_source.begin(), m_source.end());
    std::for_each(m_source.begin(), m_source.end(), print_int_one);
    std::cout << std::endl;
}

替换算法

1、一般替换：将容器内的旧元素换成新元素
函数原型：replace(iterator beg,iterator end,oldvalue,newvalue)

// 批量替换 replace(iterator beg,iterator end,oldvalue,newvalue)//将容器内的旧元素换成新元素
// parameter‌ : beg-开始迭代器   end-结束迭代器   oldvalue-旧值   newvalue-新值
void replace_test()
{
    std::vector<int> m_source{1, 2, 3, 4, 5, 5, 6, 7, 7, 2, 12};
    std::for_each(m_source.begin(), m_source.end(), print_int_one);
    std::cout << std::endl;
    std::replace(m_source.begin(), m_source.end(), 5, 0);
    std::for_each(m_source.begin(), m_source.end(), print_int_one);
    std::cout << std::endl;
}

2、条件替换：满足条件的元素进行替换
函数原型：replace_if(iterator beg,iterator end,_pred,newvalue)

// 条件替换 replace_if(iterator beg,iterator end,_pred,newvalue)满足条件的元素进行替换
// parameter‌ : beg-开始迭代器   end-结束迭代器   _pred-条件判断   newvalue-新值
void replace_if_test()
{
    std::vector<int> m_source{1, 2, 3, 4, 5, 5, 6, 7, 7, 2, 12};
    std::for_each(m_source.begin(), m_source.end(), print_int_one);
    std::cout << std::endl;
    std::replace_if(
        m_source.begin(), m_source.end(), [](int val) { return val > 6 && val < 10; }, 11);
    std::for_each(m_source.begin(), m_source.end(), print_int_one);
    std::cout << std::endl;
}

3、元素交换：交换两个相同容器内的元素
函数原型：swap(container source1,container source2)

// 元素交换 swap(container source1,container source2)交换两个相同容器内的元素
// parameter‌ : source1-容器1 source2-容器2
void swap_test()
{
    std::vector<int> m_source1{1, 2, 3, 4, 5, 6, 7};
    std::vector<int> m_source2{7, 6, 5, 4, 3, 2, 1};
    std::swap(m_source1, m_source2);
    std::for_each(m_source1.begin(), m_source1.end(), print_int_one);
    std::cout << std::endl;
    std::for_each(m_source2.begin(), m_source2.end(), print_int_one);
    std::cout << std::endl;
}

删除算法

1、删除指定区间的元素
函数原型：erase(iterator beg,iterator end)/erase(iterator beg)

//删除元素 erase(iterator beg,iterator end)删除【beg,end】区间的元素
//删除元素 erase(iterator beg)删除第beg个位置的元素
// parameter‌ : beg-开始迭代器   end-结束迭代器
void erase_test()
{
    std::vector<int> m_source{1, 2, 3, 4, 5, 6, 7};
    std::for_each(m_source.begin(), m_source.end(), print_int_one);
    std::cout << std::endl;

    m_source.erase(m_source.begin()); //删除首位元素
    std::for_each(m_source.begin(), m_source.end(), print_int_one);
    std::cout << std::endl;
    m_source.erase(m_source.begin() + 1, m_source.end() - 1); //删除区间元素
    std::for_each(m_source.begin(), m_source.end(), print_int_one);
    std::cout << std::endl;
}

2、删除指定值元素，并不执行真正的删除，只是让该值后面的元素移到前面，真正的删除用erase
函数原型：remove(iterator beg,iterator end,value)

//删除元素 remove(iterator beg,iterator end,value),并不执行真正的删除，只是让该值后面的元素移到前面，真正的删除用erase
// parameter‌ : beg-开始迭代器   end-结束迭代器   value-元素值 ，返回有效元素末尾之后的位置
void remove_test()
{
    std::vector<int> m_source{1, 2, 3, 4, 5, 5, 3, 7};
    std::for_each(m_source.begin(), m_source.end(), print_int_one);
    std::cout << std::endl;

    auto pit = std::remove(m_source.begin(), m_source.end(), 5);
    std::for_each(m_source.begin(), m_source.end(), print_int_one);
    std::cout << std::endl;
    m_source.erase(pit, m_source.end());
    std::for_each(m_source.begin(), m_source.end(), print_int_one);
    std::cout << std::endl;
}

3、按条件删除元素，并不执行真正的删除，只是让该值后面的元素移到前面，真正的删除用erase
函数原型：remove(iterator beg,iterator end,_pred)

//删除元素 remove(iterator beg,iterator end,_pred),并不执行真正的删除，只是让该值后面的元素移到前面，真正的删除用erase
// parameter‌ : beg-开始迭代器   end-结束迭代器   _pred-仿函数 ，返回有效元素末尾之后的位置
void remove_if_test()
{
    std::vector<int> m_source{1, 2, 3, 4, 5, 5, 3, 7};
    std::for_each(m_source.begin(), m_source.end(), print_int_one);
    std::cout << std::endl;

    auto pit = std::remove_if(m_source.begin(), m_source.end(), [](int val) { return val > 3; });
    std::for_each(m_source.begin(), m_source.end(), print_int_one);
    std::cout << std::endl;
    m_source.erase(pit, m_source.end());
    std::for_each(m_source.begin(), m_source.end(), print_int_one);
    std::cout << std::endl;
}

4、删除重复元素：并不执行真正的删除，同remove
函数原型：unique(iterator beg,iterator end)

//删除重复元素 unique(iterator beg,iterator end)并不执行真正的删除，同remove
// parameter‌ : beg-开始迭代器   end-结束迭代器
void unique_test()
{
    std::vector<int> m_source{1, 2, 2, 2, 3, 4, 5, 5, 3, 7};
    std::for_each(m_source.begin(), m_source.end(), print_int_one);
    std::cout << std::endl;

    auto pit = std::unique(m_source.begin(), m_source.end());
    std::for_each(m_source.begin(), m_source.end(), print_int_one);
    std::cout << std::endl;
    m_source.erase(pit, m_source.end());
    std::for_each(m_source.begin(), m_source.end(), print_int_one);
    std::cout << std::endl;
}

算数生成算法

1、累计求和：容器内元素累计求和
函数原型：accumulate(iterator beg,iterator end,value)

// 累积求和 accumulate(iterator beg,iterator end,value) 容器内元素累计求和
// parameter‌ : beg-开始迭代器 end-结束迭代器 value-求和起始值
void accumulate_test()
{
    std::vector<int> m_source1{1, 2, 3, 4, 5, 6, 7};
    std::for_each(m_source1.begin(), m_source1.end(), print_int_one);
    std::cout << std::endl;
    int totle1 = std::accumulate(m_source1.begin(), m_source1.end(), 0);
    int totle2 = std::accumulate(m_source1.begin(), m_source1.end(), 100);
    std::cout << totle1 << ' ' << totle2 << std::endl;
}

2、填充元素：向容器内填充值
函数原型：fill(iterator beg,iterator end,value)

// 填充元素 fill(iterator beg,iterator end,value) 向容器内填充值
// parameter‌ : beg-开始迭代器 end-结束迭代器 value-填充值
void fill_test()
{
    std::vector<int> m_source1{1, 2, 3, 4, 5, 6, 7};
    std::for_each(m_source1.begin(), m_source1.end(), print_int_one);
    std::cout << std::endl;
    std::fill(m_source1.begin(), m_source1.end(), 0);
    std::for_each(m_source1.begin(), m_source1.end(), print_int_one);
    std::cout << std::endl;
}

集合操作

集合的交集、并集、差集求解
函数原型：交集 set_intersection(iterator beg1,iterator end1,iterator beg2,iterator end2,iterator dest)
并集 set_union(iterator beg1,iterator end1,iterator beg2,iterator end2,iterator dest)
差集 set_difference(iterator beg1,iterator end1,iterator beg2,iterator end2,iterator dest)

// 集合算法
// 交集 set_intersection(iterator beg1,iterator end1,iterator beg2,iterator end2,iterator dest)
// 并集 set_union(iterator beg1,iterator end1,iterator beg2,iterator end2,iterator dest)
// 差集 set_difference(iterator beg1,iterator end1,iterator beg2,iterator end2,iterator dest)
// parameter‌ : beg-开始迭代器 end-结束迭代器 dest-目标容器起始迭代器
// note：两个集合必须有序
void set_test()
{
    std::vector<int> m_source1{1, 2, 3, 4, 5, 6, 7};
    std::vector<int> m_source2{5, 6, 7, 8, 9, 10, 11};
    std::for_each(m_source1.begin(), m_source1.end(), print_int_one);
    std::cout << std::endl;
    std::for_each(m_source2.begin(), m_source2.end(), print_int_one);
    std::cout << std::endl;
    std::vector<int> m_dest1;
    m_dest1.resize(std::min(m_source2.size(), m_source1.size()));
    std::set_intersection(m_source1.begin(), m_source1.end(), m_source2.begin(), m_source2.end(), m_dest1.begin()); //交集
    std::for_each(m_dest1.begin(), m_dest1.end(), print_int_one);
    std::cout << std::endl;

    m_dest1.resize(m_source1.size() + m_source2.size());
    std::set_union(m_source1.begin(), m_source1.end(), m_source2.begin(), m_source2.end(), m_dest1.begin()); //并集
    std::for_each(m_dest1.begin(), m_dest1.end(), print_int_one);
    std::cout << std::endl;

    m_dest1.resize(std::max(m_source1.size(), m_source2.size()));
    std::fill(m_dest1.begin(), m_dest1.end(), 0);
    std::set_difference(m_source1.begin(), m_source1.end(), m_source2.begin(), m_source2.end(), m_dest1.begin()); //AB差集
    std::for_each(m_dest1.begin(), m_dest1.end(), print_int_one);
    std::cout << std::endl;

    m_dest1.resize(std::max(m_source1.size(), m_source2.size()));
    std::fill(m_dest1.begin(), m_dest1.end(), 0);
    std::set_difference(m_source2.begin(), m_source2.end(), m_source1.begin(), m_source1.end(), m_dest1.begin()); //BA差集
    std::for_each(m_dest1.begin(), m_dest1.end(), print_int_one);
    std::cout << std::endl;
}

堆算法

生成堆： make_heap(iterator beg,iterator end,_pred)将指定范围内的元素生成一个堆
堆顶元素弹出： pop_heap(iterator beg,iterator end,_pred)并不真正把最大元素从堆中弹出，而是重新排序堆
新元素加入堆 push_heap(iterator beg,iterator end,_pred)要被加入到堆的元素存放在位置last-1，重新生成堆。

// 堆算法 make_heap(iterator beg,iterator end,_pred)将指定范围内的元素生成一个堆
// 堆算法 pop_heap(iterator beg,iterator end,_pred)并不真正把最大元素从堆中弹出，而是重新排序堆
// 堆算法 push_heap(iterator beg,iterator end,_pred)假设first到last-1是一个有效堆，要被加入到堆的元素存放在位置last-1，重新生成堆。
// parameter‌ : beg-开始迭代器 end-结束迭代器 _pred-仿函数
void heap_test()
{
    std::vector<int> m_source{1, 3, 2, 4, 1, 5, 7, 3, 7, 4, 7, 8};
    std::for_each(m_source.begin(), m_source.end(), print_int_one);

    std::cout << std::endl
              << "min" << std::endl;
    std::make_heap(m_source.begin(), m_source.end(), [](int a, int b) { return a > b; });
    // std::make_heap(m_source.begin(), m_source.end(), [](int a, int b) { return a < b; });
    std::for_each(m_source.begin(), m_source.end(), print_int_one);

    std::cout << std::endl
              << "pop min" << std::endl;
    std::pop_heap(m_source.begin(), m_source.end(), [](int a, int b) { return a > b; }); //与建堆顺序保持一致
    // std::pop_heap(m_source.begin(), m_source.end(), [](int a, int b) { return a <b; }); //与建堆顺序保持一致
    m_source.pop_back();
    std::for_each(m_source.begin(), m_source.end(), print_int_one);

    std::cout << std::endl
              << "push val" << std::endl;
    m_source.emplace_back(10);
    std::push_heap(m_source.begin(), m_source.end(), [](int a, int b) { return a > b; }); //与建堆顺序保持一致
    std::push_heap(m_source.begin(), m_source.end(), [](int a, int b) { return a < b; }); //与建堆顺序保持一致
    std::for_each(m_source.begin(), m_source.end(), print_int_one);
}

STL常用容器

顺序性容器 vector ：从后面快速插入/删除，能直接访问元素
顺序性容器 deque： 从前面/后面快速插入/删除，能直接访问元素，和vector类似
顺序性容器 list： 双链表，从任何地方快速插入/删除
关联容器 set ：快速查找，不允许重复值,插入后自动排序
关联容器 multiset ：快速查找，允许重复值，插入后自动排序
关联容器 map： 一对一映射，基于关键字快速查找，不允许重复值,所有元素根据键值自动排序
关联容器 multimap ：一对多映射，基于关键字快速查找，允许重复值，所有元素根据键值自动排序
适配器容器 stack：后进先出
适配器容器 queue ：先进先出
适配器容器 priority_queue ：优先级队列 最高优先级的元素先出列

这些容器的操作无非就是front(),back(),size(),empty(),insert(),erase(),clear(),resize(),push_back(),pop_back(),top()等，主要看个vector功能，其他的基本一致（适配器容器除外）

打印数据

//打印单个数据
void print_int_one(int val)
{
    std::cout << val << ' ';
}

//打印map数据
void print_map_two(std::pair<int, std::string> pit)
{
    std::cout << pit.first << ':' << pit.second << ' ';
}

vector

// 顺序性容器 vector 从后面快速插入/删除，能直接访问元素
// 优点：连续存储、动态扩展、随机访问
// 缺点：只能在尾部进行插入/删除，动态添加超过默认分配大小时要进行内存再分配，消耗性能，建议创建vector时就指定空间大小
void C_STL_Vector()
{
    //初始化
    std::vector<int> m_container1(10); //初始化容器大小为10，默认填充0
    std::cout << "m_container1: ";
    std::for_each(m_container1.begin(), m_container1.end(), print_int_one);

    std::vector<int> m_container2(10, 2); //初始化容器大小为10，默认填充2
    std::cout << std::endl
              << "m_container2: ";
    std::for_each(m_container2.begin(), m_container2.end(), print_int_one);

    std::vector<int> m_container3{1, 2, 3, 4, 5, 6, 7, 8}; //初始并定义容器元素
    std::cout << std::endl
              << "m_container3: ";
    std::for_each(m_container3.begin(), m_container3.end(), print_int_one);

    std::vector<int> m_container4(m_container3); //拷贝构造，将m_container3的元素拷贝给m_container4
    std::cout << std::endl
              << "m_container4: ";
    std::for_each(m_container4.begin(), m_container4.end(), print_int_one);

    std::vector<int> m_container5(m_container3.begin(), m_container3.end() - 1); //拷贝构造m_container3中的部分元素
    std::cout << std::endl
              << "m_container5: ";
    std::for_each(m_container5.begin(), m_container5.end(), print_int_one);
    std::cout << std::endl;

	//功能
    std::vector<int> m_container{1, 2, 3, 4, 5, 6, 7, 8, 9};
    m_container.push_back(100);    //尾部插入，构造后再插入
    m_container.emplace_back(101); //尾部插入，原地插入，没有拷贝规程，更高效
    std::for_each(m_container.begin(), m_container.end(), print_int_one);
    std::cout << std::endl;
    std::cout << "first: " << m_container.front() << std::endl;       //首个元素
    std::cout << "last: " << m_container.back() << std::endl;         //最后一个元素
    std::cout << "size: " << m_container.size() << std::endl;         //容器大小
    std::cout << "empty: " << m_container.empty() << std::endl;       //是否为空
    std::cout << "capacity: " << m_container.capacity() << std::endl; //容器容量，和大小不是一个概念

    m_container.insert(m_container.begin() + 1, 3, 10); //在m_container[1]后面插入3个值为10的元素
    std::for_each(m_container.begin(), m_container.end(), print_int_one);
    std::cout << std::endl;

    m_container.erase(m_container.begin() + 1, m_container.begin() + 5); //在删除m_container[1]到m_container[5]之间的元素，不包括m_container[5]
    std::for_each(m_container.begin(), m_container.end(), print_int_one);
    std::cout << std::endl;

    m_container.clear(); //清空容器
    std::cout << "size: " << m_container.size() << std::endl;
    std::cout << std::endl;
    m_container.resize(5); //重设容器大小
    std::cout << "size: " << m_container.size() << std::endl;
}

deque

//顺序性容器 deque 从前面/后面快速插入/删除，能直接访问元素，和vector类似
void C_STL_Deque()
{
    std::deque<int> m_container{1, 2, 3, 4, 5, 6}; //初始化同vector
    m_container.push_back(100);                    //尾添
    m_container.push_front(101);                   //首添
    std::for_each(m_container.begin(), m_container.end(), print_int_one);
    std::cout << std::endl;

    m_container.pop_back();  //尾删
    m_container.pop_front(); //首删
    std::for_each(m_container.begin(), m_container.end(), print_int_one);
    std::cout << std::endl;

    //其他功能同vector
}

list

//顺序性容器 list 双链表，从任何地方快速插入/删除
void C_STL_List()
{
    std::list<int> m_container{1, 2, 3, 4, 5};              //初始化同vector
    m_container.remove_if([](int val) { return val > 3; }); //删除值大于3的元素
    std::for_each(m_container.begin(), m_container.end(), print_int_one);
    std::cout << std::endl;

    m_container.remove(1); //删除值为1的元素
    std::for_each(m_container.begin(), m_container.end(), print_int_one);
    std::cout << std::endl;

    //其他功能同vector
}

set/multiset

//关联容器 set 快速查找，不允许重复值,插入后自动排序
//关联容器 multiset 快速查找，允许重复值
void C_STL_set()
{
    std::set<int> m_container{1, 2, 3, 1, 3, 4, 5, 5}; //初始化同vector，不能有重复值
    std::for_each(m_container.begin(), m_container.end(), print_int_one);
    std::cout << std::endl;

    std::multiset<int> m_container1{1, 2, 2, 3, 1, 3, 4, 2, 7}; //初始化同vector，可以有重复值
    std::for_each(m_container1.begin(), m_container1.end(), print_int_one);
    std::cout << std::endl;

    //其他功能同vector
}

map/multimap

//关联容器 map 一对一映射，基于关键字快速查找，不允许重复值,所有元素根据键值自动排序
//关联容器 multimap 一对多映射，基于关键字快速查找，允许重复值
void C_STL_map()
{
    std::map<int, std::string> m_container{{1, "gxf"}, {2, "mko"}, {5, "gxf"}, {1, "erf"}, {6, "sdf"}}; //除了元素数量不一样，初始化同vector
    std::for_each(m_container.begin(), m_container.end(), print_map_two);
    std::cout << std::endl;

    m_container.insert(std::pair<int, std::string>(3, "wse"));
    std::for_each(m_container.begin(), m_container.end(), print_map_two);
    std::cout << std::endl;

    std::multimap<int, std::string> m_container1{{1, "gxf"}, {2, "mko"}, {1, "gxf"}, {1, "erf"}, {6, "sdf"}}; //除了元素数量不一样，初始化同vector
    std::for_each(m_container1.begin(), m_container1.end(), print_map_two);
    std::cout << std::endl;

    //其他功能同vector，通过键值进行索引
}

stack

//适配器容器 stack 后进先出
void C_STL_stack()
{
    std::stack<int> m_container;
    m_container.push(1); //元素入栈
    m_container.push(2);
    m_container.push(3);
    m_container.push(4);
    m_container.push(5);
    std::cout << m_container.top() << std::endl;   //返回栈顶元素
    std::cout << m_container.size() << std::endl;  //栈大小
    std::cout << m_container.empty() << std::endl; //栈是否为空
    m_container.pop();                             //删除栈顶元素
    std::cout << m_container.top() << std::endl;   //返回栈顶元素
    //不提供任何遍历方法
}

queue

//适配器容器 queue 先进先出
void C_STL_queue()
{
    std::queue<int> m_container;
    m_container.push(1); //元素入队尾
    m_container.push(2);
    m_container.push(3);
    m_container.push(4);
    m_container.push(5);
    std::cout << m_container.back() << std::endl;  //队尾元素
    std::cout << m_container.front() << std::endl; //队首元素
    std::cout << m_container.size() << std::endl;  //队列大小
    std::cout << m_container.empty() << std::endl; //队列是否为空
    m_container.pop();                             //删除队首元素
    std::cout << m_container.front() << std::endl; //返回队首元素
    //不提供任何遍历方法
}

priority_queue

//适配器容器 priority_queue 优先级队列 最高优先级的元素先出列
struct m_struct1 {
    int age;
    std::string name;
    friend bool operator<(m_struct1 m1, m_struct1 m2)
    {
        return m1.age < m2.age;
    }
};

struct m_struct2 {
    int age;
    std::string name;
};
void C_STL_priority_queue()
{
    std::priority_queue<int> m_container; //默认递减
    // std::priority_queue<int, std::vector<int>, std::less<int> > m_container2;//默认优先级
    // std::priority_queue<int, std::vector<int>, std::greater<int> > m_container3;

    //结构体类型 第一种方案
    std::priority_queue<m_struct1> m_container2;
    m_struct1 m1{10, "gfx"};
    m_struct1 m2{18, "zlw"};
    m_struct1 m3{8, "fhy"};
    m_container2.push(m1); //入队列
    m_container2.push(m2);
    m_container2.push(m3);
    while (!m_container2.empty()) {                                                   //是否为空
        std::cout << m_container2.top().name << ":" << m_container2.top().age << ' '; //队首元素
        m_container2.pop();                                                           //删除队首元素
    }
    std::cout << std::endl;

    auto cmp = [](m_struct2 a, m_struct2 b) { return a.age < b.age; };
    std::priority_queue<m_struct2, std::vector<m_struct2>, decltype(cmp)> m_container3(cmp);
    m_struct2 m11{10, "gfx"};
    m_struct2 m22{18, "zlw"};
    m_struct2 m33{8, "fhy"};
    m_container3.push(m11);
    m_container3.push(m22);
    m_container3.push(m33);
    while (!m_container3.empty()) {
        std::cout << m_container3.top().name << ":" << m_container3.top().age << ' ';
        m_container3.pop();
    }
    std::cout << std::endl;

    //不提供任何遍历方法
}
我有大病
关注
专栏目录
stl常用算法(Algorithms)介绍(stl排序算法、非变序型队列)
09-04
在这个话题中，我们将深入探讨STL中的一些常用算法，特别是排序算法和非变序型队列算法。 首先，让我们来看一下排序算法。在STL中，最常用的排序算法是`std::sort`，它位于`<algorithm>`头文件中。`std::sort`可以...
c++模板stl常用算法
09-01
### C++模板STL常用算法 #### 前言 C++是一种强大的编程语言，它支持多种编程范式，包括面向对象编程、泛型编程等。其中，泛型编程是通过模板来实现的，模板允许程序员编写能处理多种类型数据的代码。标准模板库...
STL常用容器及算法介绍
m0_65305142的博客
06-29 1689
STL指的是C++标准模板库（Standard Template Library），本文介绍常用算法及容器。
STL常用算法
qq_24472227的博客
06-06 1653
1、常用遍历算法 2、常用查找算法 3、常用排序算法 4、常用拷贝和替换算法 5、常用算术生成算法 6、常用集合算法
STL常用容器及使用总结
ymhdt的博客
07-15 864
上述介绍的八种关联容器可以分为两类集合（set）和映射（map）。其中set的无序版本是unordered_set，键值可重复版本是multset，无序且键值可重复版本是unordered_multset。map的无序版本是unordered_map，键值可重复版本是multmap，无序且键值可重复版本是unordered_multmap。
c++---STL常用算法
m0_50046535的博客
04-25 3416
概述： 算法主要是由头文件<algorithm><functional><numeric>组成 <algorithm>是所有stl头文件中最大的一个，涉及比较，交换，查找，遍历，复制，修改等操作 <numeric>体积很小，只包括几个在序列上进行简单数学运算的模板函数 <functional>定义了一些类模板，用以声明函数对象 一、常用遍历算法 for_each 遍历容器 transform 搬运容...
STL常用算法——排序算法
万里顾一程的博客
10-31 1321
合并排序，merge() 函数用于将 2 个有序序列合并为 1 个有序容器，前提是这 2 个有序容器的排序规则相同（要么都是升序，要么都是降序）。并且最终借助该函数获得的新有序容器，其排序规则也和这 2 个有序容器要相同。sort() 函数在对自定义的类对象实现排序时，需要在该类的内部提供移动构造函数和移动赋值运算符。sort()：对容器或普通数组中范围内的元素进行排序，默认进行升序排序，也可以自定义排序规则。reverse()函数：将容器指定范围内的元素进行反转。函数原型：该函数有以下两种格式。
C++ STL常用容器
会思想的苇草i的博客
01-15 2148
C++标准模板库（STL）是C++编程中不可或缺的部分，它提供了丰富的数据结构和算法。本文将带你初识C++ STL，包括容器（如vector、list、map等）、算法（如排序、查找、遍历等）以及迭代器等内容。我们将对每种容器和算法进行简要介绍，并给出示例代码加深理解。通过本文的阅读，读者将能够初步掌握C++ STL的基本用法，为日后的程序设计打下坚实的基础。
C++——STL标准模板库——常用算法归纳
qq_42106610的博客
02-01 1185
STL 提供的部分常用算法归纳。
C++中STL常用算法
兰天禄的博客
04-02 1270
STL的常用算法1、常用的遍历算法1、for_each:遍历容器元素2、transform算法 将指定容器区间元素搬运到另一容器中2、常用的查找算法2.1、find算法 查找元素2、find_if条件查找2.3、adjacent_find算法 查找相邻重复元素2.4、binary_search算法 二分查找法（容器必须有序）2.5、count算法 统计元素出现次数2.6、count_if算法 统计...
STL介绍及常用算法详解
LJJJJ7的博客
08-28 1124
两个容器，分别是"有序集合"和"有序多重集合"，即前者的元素不能重复，而后者可以包含若干个相等的元素。set 和 multiset 的内部实现是一棵红黑树，它们支持的函数基本相同。，因为它们都是容器，容器的clear函数会清空容器中的所有元素，而队列，优先队列和栈中的元素是动态申请的，所以没有必要提供clear函数。提供一种方法，使之能够依序寻访某个容器所合的各个元素，而又无需暴露该容器的内部表示方式每个容器都有自己专属的迭代器。（即弹出的元素十最后一个插入的元素）栈和队列是相似的，只不过它是。
STL概念及常用容器、函数对象，算法使用总结
断点_C的博客
01-11 1171
文章目录STLSTL的诞生STL的基本概念STL六大组件STL中容器、算法、迭代器容器算法迭代器初识vector存放内置的数据类型vector存放自定义数据类型vector容器中嵌套容器STL -常用容器string容器string基本概念string构造函数string赋值操作string字符串拼接string查找和替换string字符串比较string字符存取string插入和删除string字串vector容器vector容器基本概念vector构造函数vector赋值操作vector容量和大小vec
STL常用算法大全
12-02
STL 常用算法大全 STL（Standard Template Library）提供了丰富的算法库，涵盖了查找、排序、数值计算等多方面的算法。这些算法可以帮助开发者快速、高效地处理数据。 查找算法（13 个） 1. `adjacent_find`：在...
力扣 困难 154.寻找旋转排序数组中的最小值 II
qq_51352130的博客
09-23 371
153.寻找旋转排序数组中的最小值在此基础上，进行二分之前，单独处理一下左指针和最后一个数相同的情况就好了。left++;} else {
二叉树最小深度
2301_80161204的博客
09-27 217
25[0, 105]
使用Python实现图形学的纹理映射算法
qq_42568323的博客
09-27 800
纹理映射的基本概念是将二维图像（纹理）应用于三维模型的表面，以便在渲染时提供更多的细节和视觉效果。纹理坐标生成：为每个顶点生成对应的纹理坐标，通常使用归一化的二维坐标系统。纹理采样：根据生成的纹理坐标从纹理图像中获取颜色值。光照计算：结合光照模型，计算最终颜色，产生更真实的效果。图像合成：将计算得到的颜色与其他渲染信息合成，生成最终图像。纹理映射不仅可以用于简单的颜色填充，还可以模拟表面细节、光照变化等，提升渲染效果。
atcoder abc372 启发式合并， dp
2201_75845839的博客
09-22 505
现在考虑如何存数据。可以用并查集合并两个集合，并且在合并的时候一定要将小的集合合并到大的集合中去，因为小集合合并到大集合中，最后的集合一定大于小集合元素数量的两倍，因此合并的时间复杂度不会超过logn。思路：判断当前变化的位置对结果是否会产生影响，在询问前先计算有多少ABC, 每次变换位置x前后扫描一下[x - 2, x + 2]范围内是否有ABC，变换前有让cnt --， 变换后有让cnt ++思路：三进制转换，可以参考二进制，先把当前可以加入的最大的3的幂次加入,这样一定可以凑出答案。
904. 水果成篮
最新发布
YQ20210216的博客
09-27 208
转化，找出一个最长的子数组长度，子数组中不超过两种类型的水果，要记录水果类型和水果数量，所以要使用unord_map，key来记录水果中类，valuse记录水果数量，当right开始增加的时候，将水果种类加入到哈希表中，当水果中类超过两种时，控制left使得水果种类回到两种。你想要尽可能多地收集水果。你正在探访一家农场，农场从左到右种植了一排果树。这些树用一个整数数组。，返回你可以收集的水果的。
Hello Algorithm：Capture 1，2 初识算法
m0_62716099的博客
09-27 470
能力有限，欢迎大家一同交流讨论！
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值