C++如何使用STL容器进行合并操作

C++中合并STL容器需根据需求选择方法：使用std::merge可将两个已排序序列合并为有序序列，适用于有序合并场景；通过insert或splice实现简单拼接；利用std::set_union等算法处理集合操作以避免重复；对复杂对象需定义比较规则（如重载operator</blockquote>

C++中对STL容器进行合并操作，核心在于理解你想要“合并”的具体含义。最直接且功能强大的方法是利用

std::merge

登录后复制

算法，它能将两个已排序的序列合并成一个单一的、同样排序的序列。当然，根据需求，我们也可以通过迭代器、插入操作或特定的集合算法来实现不同形式的“合并”，比如简单地将一个容器的内容追加到另一个容器，或者进行集合的并集、交集操作。

解决方案

要实现STL容器的合并，我们主要依赖标准库提供的算法和容器自身的成员函数。

使用

std::merge

登录后复制

进行有序合并

当你的目标是将两个已排序的序列合并成一个新的已排序序列时，

std::merge

登录后复制

是你的首选。它效率很高，通常是线性时间复杂度O(N+M)，其中N和M是两个输入序列的大小。

#include <iostream>
#include <vector>
#include <algorithm> // for std::merge
#include <iterator>  // for std::back_inserter

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

    // 预留足够的空间，避免不必要的重新分配，提高效率
    merged_vec.reserve(vec1.size() + vec2.size());

    // 使用std::merge将vec1和vec2合并到merged_vec中
    // std::back_inserter用于向vector末尾添加元素
    std::merge(vec1.begin(), vec1.end(),
               vec2.begin(), vec2.end(),
               std::back_inserter(merged_vec));

    std::cout << "Merged Vector: ";
    for (int x : merged_vec) {
        std::cout << x << " ";
    }
    std::cout << std::endl; // Output: 1 2 3 4 5 6 7 8 9 10 

    // 也可以自定义比较函数，例如降序合并
    std::vector<int> vec3 = {9, 7, 5, 3, 1};
    std::vector<int> vec4 = {10, 8, 6, 4, 2};
    std::vector<int> merged_desc_vec;
    merged_desc_vec.reserve(vec3.size() + vec4.size());

    std::merge(vec3.begin(), vec3.end(),
               vec4.begin(), vec4.end(),
               std::back_inserter(merged_desc_vec),
               std::greater<int>()); // 使用std::greater进行降序比较

    std::cout << "Merged Descending Vector: ";
    for (int x : merged_desc_vec) {
        std::cout << x << " ";
    }
    std::cout << std::endl; // Output: 10 9 8 7 6 5 4 3 2 1

    return 0;
}

登录后复制

其他“合并”方式

1. 简单拼接 (Concatenation): 如果你只是想把一个容器的所有元素追加到另一个容器的末尾，而不关心排序，可以直接使用容器的

   insert

   登录后复制
   方法或

   push_back

   登录后复制
   循环。

   立即学习“C++免费学习笔记（深入）”；

   std::vector<int> a = {1, 2, 3};
   std::vector<int> b = {4, 5, 6};
   a.insert(a.end(), b.begin(), b.end()); // a 现在是 {1, 2, 3, 4, 5, 6}

   登录后复制

   对于

   std::list

   登录后复制
   ，还有

   splice

   登录后复制
   操作，可以高效地将一个列表的元素移动到另一个列表，而无需复制。

2. 集合操作: 如果你处理的是集合（即元素唯一且通常有序），那么

   std::set_union

   登录后复制
   、

   std::set_intersection

   登录后复制
   、

   std::set_difference

   登录后复制
   等算法可能更符合你的“合并”需求。它们同样要求输入序列是已排序的。

   std::vector<int> s1 = {1, 2, 3, 4, 5};
   std::vector<int> s2 = {3, 4, 5, 6, 7};
   std::vector<int> union_result;
   std::set_union(s1.begin(), s1.end(),
                  s2.begin(), s2.end(),
                  std::back_inserter(union_result));
   // union_result: {1, 2, 3, 4, 5, 6, 7}

   登录后复制

STL容器合并时，如何确保数据有序性并避免重复元素？

确保数据有序性和避免重复是合并操作中非常常见的需求，尤其是在处理像日志、传感器数据或者用户ID列表这类场景。我个人觉得，这其实是合并操作的“高级形态”，因为它不仅仅是简单地堆叠数据。

对于有序性，

std::merge

登录后复制

本身就要求输入是已排序的。如果你的源容器（比如

std::vector

登录后复制

或

std::list

登录后复制

）不是有序的，那么在调用

std::merge

登录后复制

之前，你必须先对它们进行排序。最直接的方法就是使用

std::sort

登录后复制

算法：

std::vector<int> unsorted_vec1 = {5, 1, 8, 3};
std::vector<int> unsorted_vec2 = {9, 2, 7, 4};

std::sort(unsorted_vec1.begin(), unsorted_vec1.end()); // 现在vec1是 {1, 3, 5, 8}
std::sort(unsorted_vec2.begin(), unsorted_vec2.end()); // 现在vec2是 {2, 4, 7, 9}

std::vector<int> result_vec;
result_vec.reserve(unsorted_vec1.size() + unsorted_vec2.size());
std::merge(unsorted_vec1.begin(), unsorted_vec1.end(),
           unsorted_vec2.begin(), unsorted_vec2.end(),
           std::back_inserter(result_vec));
// result_vec: {1, 2, 3, 4, 5, 7, 8, 9}

登录后复制

如果忘记排序，

std::merge

登录后复制

的结果将是未定义的，通常你会得到一个看似合并了但实际无序的序列，这在调试时会让人头疼。

至于避免重复元素，这通常需要额外的步骤或者选择特定的容器类型。

1. 使用

   std::set_union

   登录后复制
   : 如果你的输入序列本身就是已排序且不含重复元素的（比如来自

   std::set

   登录后复制
   或经过

   std::unique

   登录后复制
   处理的

   std::vector

   登录后复制
   ），那么

   std::set_union

   登录后复制
   是最佳选择。它会生成一个包含所有不重复元素的已排序序列。

2. 先合并后去重: 如果输入序列可能含有重复元素，或者你先使用了

   std::merge

   登录后复制
   ，那么你可以在合并之后再进行去重操作。

   std::vector<int> combined_with_duplicates = {1, 2, 2, 3, 4, 4, 5}; // 假设这是merge的结果
   
   // std::unique将相邻的重复元素移到末尾，并返回新逻辑末尾的迭代器
   auto last_unique = std::unique(combined_with_duplicates.begin(), combined_with_duplicates.end());
   
   // 使用erase移除实际的重复元素
   combined_with_duplicates.erase(last_unique, combined_with_duplicates.end());
   // combined_with_duplicates: {1, 2, 3, 4, 5}

   登录后复制

   需要注意的是，

   std::unique

   登录后复制
   只处理相邻的重复元素，所以它要求序列必须是已排序的。如果你的序列在合并后是无序的，你需要先

   std::sort

   登录后复制
   再

   std::unique

   登录后复制
   。

3. 使用

   std::set

   登录后复制
   或

   std::map

   登录后复制
   作为目标容器: 最“省心”的方法是直接将元素插入到

   std::set

   登录后复制
   或

   std::map

   登录后复制
   中。这些容器天生就保证了元素的唯一性和有序性。
   

   中解商务通

   实时捕捉 一旦访问者打开您的网站，系统会立即显示，这时您就可以查看用户的信息，如：来自搜索引擎关键词、友情链接或直接访问；访问者的IP地址，所在地区，正在访问哪个网页；以及访问者使用的操作系统、浏览器、显示器屏幕分辨率颜色深度等。 主动出击 变被动为主动，可以主动邀请访问者进行洽谈勾通，帮助客户深入了解您的企业和产品，同时获得对方的采购意向、联系方式等信息。 互动交流 主动销售和在线客服合二为一，

   0

   查看详情

   std::vector<int> vec_a = {1, 5, 3, 5};
   std::vector<int> vec_b = {2, 4, 1, 6};
   
   std::set<int> unique_elements;
   for (int x : vec_a) {
       unique_elements.insert(x);
   }
   for (int x : vec_b) {
       unique_elements.insert(x);
   }
   // unique_elements现在包含 {1, 2, 3, 4, 5, 6}，自动排序且无重复

   登录后复制

   这种方法的缺点是每次插入的开销是O(log N)，对于大量元素，可能不如先合并到

   vector

   登录后复制
   再排序去重效率高，但代码简洁，不易出错。

总结一下，要确保有序且无重复，通常的流程是：对源容器进行排序 -> 使用

std::merge

登录后复制

或

std::set_union

登录后复制

合并 -> （如果需要）使用

std::unique

登录后复制

去重。或者，如果你对性能要求不是极致，直接使用

std::set

登录后复制

作为中间或最终容器会非常方便。

C++中合并不同类型或复杂对象STL容器的实用技巧有哪些？

当我们谈论合并不同类型或复杂对象的STL容器时，事情就变得有点意思了。简单地将

int

登录后复制

合并到

int

登录后复制

容器里固然直接，但现实世界的数据往往更复杂。

首先，明确一点：STL的合并算法（如

std::merge

登录后复制

）是基于元素类型兼容性的。这意味着，如果你要合并

std::vector<Person>

登录后复制

和

std::vector<Person>

登录后复制

，那没问题；但如果你想直接合并

std::vector<int>

登录后复制

和

std::vector<std::string>

登录后复制

到一个单一的容器里，那在C++的强类型系统下是行不通的，因为最终容器的元素类型必须是确定的。

1. 为复杂对象定义比较规则

当你的容器存储的是自定义的结构体或类对象时，比如

struct Person { std::string name; int age; };

登录后复制

，

std::merge

登录后复制

或

std::sort

登录后复制

需要知道如何比较这些对象。你有几种方式来提供比较规则：

• 重载

  operator<

  登录后复制
  : 这是最C++范儿的方式。在你的类定义内部或外部重载

  operator<

  登录后复制
  ，让它返回两个对象之间的小于关系。

  struct Person {
      std::string name;
      int age;
  
      // 重载 operator<，用于排序和合并
      bool operator<(const Person& other) const {
          if (name != other.name) {
              return name < other.name;
          }
          return age < other.age;
      }
  };
  
  // ... 之后你可以直接对 Person 对象的 vector 使用 std::sort 和 std::merge
  std::vector<Person> team_a = {{"Alice", 30}, {"Bob", 25}};
  std::vector<Person> team_b = {{"Charlie", 35}, {"Alice", 28}}; // 注意Alice重复但age不同
  
  std::sort(team_a.begin(), team_a.end());
  std::sort(team_b.begin(), team_b.end());
  
  std::vector<Person> merged_team;
  std::merge(team_a.begin(), team_a.end(),
             team_b.begin(), team_b.end(),
             std::back_inserter(merged_team));
  // Merged: {{"Alice", 28}, {"Alice", 30}, {"Bob", 25}, {"Charlie", 35}} (按name, then age排序)

  登录后复制

  这是一种侵入式的方法，意味着你的类需要知道如何比较自己。

• 提供自定义比较函数（Lambda/Functor）: 如果你不想修改类定义，或者需要根据不同场景使用不同的比较逻辑，可以向

  std::merge

  登录后复制
  等算法传递一个自定义的比较函数对象（Functor）或Lambda表达式。

  // 假设 Person 类没有重载 operator<
  struct Person {
      std::string name;
      int age;
  };
  
  // 定义一个 lambda 表达式作为比较器，按年龄排序
  auto compare_by_age = [](const Person& p1, const Person& p2) {
      return p1.age < p2.age;
  };
  
  std::vector<Person> team_a = {{"Alice", 30}, {"Bob", 25}};
  std::vector<Person> team_b = {{"Charlie", 35}, {"Alice", 28}};
  
  std::sort(team_a.begin(), team_a.end(), compare_by_age); // 使用年龄排序
  std::sort(team_b.begin(), team_b.end(), compare_by_age);
  
  std::vector<Person> merged_team_by_age;
  std::merge(team_a.begin(), team_a.end(),
             team_b.begin(), team_b.end(),
             std::back_inserter(merged_team_by_age),
             compare_by_age);
  // Merged: {{"Bob", 25}, {"Alice", 28}, {"Alice", 30}, {"Charlie", 35}} (按age排序)

  登录后复制

  这种方式非常灵活，可以在运行时决定比较策略。

2. 合并不同容器类型（但元素类型相同）

std::merge

登录后复制

以及其他STL算法，它们操作的是迭代器，而不是具体的容器类型。这意味着你可以轻松地合并来自

std::vector

登录后复制

和

std::list

登录后复制

的元素，只要它们的元素类型兼容，并且你有一个合适的输出迭代器。

#include <list>
// ... (其他头文件)

std::vector<double> vec_data = {1.1, 3.3, 5.5};
std::list<double> list_data = {2.2, 4.4, 6.6};

std::vector<double> merged_data;
merged_data.reserve(vec_data.size() + list_data.size());

std::merge(vec_data.begin(), vec_data.end(),
           list_data.begin(), list_data.end(),
           std::back_inserter(merged_data));
// merged_data: {1.1, 2.2, 3.3, 4.4, 5.5, 6.6}

登录后复制

这挺强大的，它让我们能够混合搭配不同存储特性的容器，只要最终目标是统一的。

3. 处理真正“不同类型”的合并（非直接合并）

如果你的意思是，一个容器里是

int

登录后复制

，另一个是

std::string

登录后复制

，你想要把它们“合并”到一个容器里，这就不再是传统意义上的

std::merge

登录后复制

能解决的问题了。C++的容器是同质的，一个

std::vector<T>

登录后复制

只能装

T

登录后复制

类型的对象。

在这种情况下，你需要考虑：

• 共同基类或接口: 如果这些不同类型的对象都继承自一个共同的基类（或者实现了共同的接口），你可以使用

  std::vector<std::unique_ptr<BaseClass>>

  登录后复制
  或

  std::vector<BaseClass*>

  登录后复制
  来存储它们。

  class Shape { public: virtual void draw() const = 0; virtual ~Shape() = default; };
  class Circle : public Shape { /* ... */ };
  class Square : public Shape { /* ... */ };
  
  std::vector<std::unique_ptr<Shape>> shapes1;
  shapes1.push_back(std::make_unique<Circle>());
  // ...
  std::vector<std::unique_ptr<Shape>> shapes2;
  shapes2.push_back(std::make_unique<Square>());
  // ...
  
  // 合并到新的容器
  std::vector<

  登录后复制

以上就是C++如何使用STL容器进行合并操作的详细内容，更多请关注php中文网其它相关文章！

相关标签：

go ai c++ ios 标准库 String sort 成员函数 结构体 int 循环 Lambda 指针 继承 接口 堆 Struct operator map 对象 算法 传感器

大家都在看：

为什么Golang的函数参数都是值传递 分析指针与引用传递的区别 如何为C++搭建区块链节点开发环境 Hyperledger Fabric集成 Golang的包管理机制如何运作 介绍go mod的依赖管理方式 为什么Golang要禁止循环引用 讲解编译器的包依赖检查规则 Golang的select语句如何实现多路复用 剖析非阻塞IO处理机制