【C++】常用集合算法

于 2022-08-09 12:55:16 发布
阅读量1.1k 收藏 5
点赞数 1
分类专栏： C++ 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xuan3215/article/details/126230117
版权

目录

set_intersection

set_union

set_difference

常用集合算法简介：

  • set_intersection        求两个容器的交集
  • set_union                  求两个容器的并集
  • set_difference           求两个容器的差集

set_intersection

功能;

  • 求两个相同集合（必须是有序序列）的交集

函数原型：

set_intersection(iterator beg1, iterator end1, iterator beg2, iterator end2, iterator dest);

beg1 —— 容器 1 开始迭代器

end1 —— 容器 1 结束迭代器

beg2 —— 容器 2 开始迭代器

end2 —— 容器 2 结束迭代器

dest  —— 目标容器开始迭代器

测试代码：

#include<iostream>
#include<algorithm>
#include<vector>
#include<string>
using namespace std;

class Person {
public:
    Person(string name, int age) :m_Name(name), m_Age(age) {}
    Person() {}
    string m_Name;
    int m_Age;
};

ostream& operator<<(ostream& cout, const Person& p) {
    cout << p.m_Name << " " << p.m_Age << endl;
    return cout;
}

template<typename T>
void PrintVector(const T& x) {
    cout << x << " ";
}

// 内置数据类型交集
void test01() {
    vector<int>v1; // 有序
    v1.push_back(3);
    v1.push_back(4);
    v1.push_back(5);
    v1.push_back(6);
    vector<int>v2; // 有序
    v2.push_back(4);
    v2.push_back(5);
    v2.push_back(6);

    vector<int>v_target; // 目标容器

    // 计算大小目标容器需要的合适大小
    size_t v_size = (v1.size() > v2.size()) ? v2.size() : v1.size();
    
    // 或者用 min 算法
    v_size = min(v1.size(), v2.size());

    // 需要给目标容器开辟内存 v_size
    v_target.resize(v_size);  // 这个空间可能大了，默认值为 0 

    // 求集合交集到目标容器，返回的是最后一个交集的迭代器
    vector<int>::iterator EndIt = set_intersection(v1.begin(), v1.end(), v2.begin(), v2.end(), v_target.begin());

    // 遍历的时候可以不用遍历到容器末尾，只需要遍历到交集的最后一个元素即可
    for_each(v_target.begin(), EndIt, PrintVector<int>); // 遍历
    cout << endl;
}

class Person_sort {
public:
    bool operator()(const Person& p1, const Person& p2) {
        return (p1.m_Age < p2.m_Age);
    }
};

// 自定义数据类型交集
void test02() {
    vector<Person>v1; // 有序
    vector<Person>v2; // 有序
    Person p1("A", 19);
    Person p2("B", 18);
    Person p3("C", 20);
    Person p4("D", 21);  
    
    v1.push_back(p1);
    v1.push_back(p2);
    v1.push_back(p3);

    v2.push_back(p1);
    v2.push_back(p2);
    v2.push_back(p3);
    v2.push_back(p4);

    sort(v1.begin(), v1.end(), Person_sort());
    sort(v2.begin(), v2.end(), Person_sort());

    vector<Person>v_target;

    // 计算大小目标容器需要的合适大小
    size_t v_size = (v1.size() > v2.size()) ? v2.size() : v1.size();

    v_size = min(v1.size(), v2.size()); // min 算法

    // 需要给目标容器开辟内存 v_size
    v_target.resize(v_size);

    // 放上排序规则仿函数，返回最后一个交集的迭代器
    vector<Person>::iterator EndIt = set_intersection(v1.begin(), v1.end(), v2.begin(), v2.end(), v_target.begin(), Person_sort());
    for_each(v_target.begin(), EndIt, PrintVector<Person>); // 遍历
    cout << endl;
}

int main() {
    test01();
    test02();
    system("pause");
    return 0;
}

运行结果：

  • 两个容器必须是有序序列
  • 目标容器取两个容器中的最小值
  • set_intersection 返回值是交集最后一个元素的位置

set_union

功能：

  • 求两个集合（有序序列）的并集

函数原型：

set_union(iterator beg1, iterator end1, iterator beg2, iterator end2, iterator dest);

beg1 ——  容器 1 开始迭代器

end1 ——  容器 1  结束迭代器

beg2 —— 容器 2 开始迭代器

end2 —— 容器 2 结束迭代器

dest  —— 目标容器开始迭代器

测试代码：

#include<iostream>
#include<algorithm>
#include<vector>
#include<string>
using namespace std;

class Person {
public:
    Person(string name, int age) :m_Name(name), m_Age(age) {}
    Person() {}
    string m_Name;
    int m_Age;
};

// 重载 << 
ostream& operator<<(ostream& cout, const Person& p) {
    cout << p.m_Name << " " << p.m_Age << endl;
    return cout;
}

// 输出模板函数
template<typename T>
void PrintVector(const T& x) {
    cout << x << " ";
}

// 内置数据类型并集
void test01() {
    vector<int>v1; // 有序
    vector<int>v2; // 有序
    v1.push_back(3);
    v1.push_back(4);
    v1.push_back(5);
    v1.push_back(6);

    v2.push_back(5);
    v2.push_back(6);
    v2.push_back(7);

    vector<int>v_target;
    v_target.resize(v1.size() + v2.size()); // 并集容量要取两个容器的和
    
    // 返回并集最后一个元素的迭代器
    vector<int>::iterator EndIt = set_union(v1.begin(), v1.end(), v2.begin(), v2.end(), v_target.begin());
    for_each(v_target.begin(), EndIt, PrintVector<int>);
    cout << endl;
}

// 排序仿函数
class Person_sort {
public:
    bool operator()(const Person& p1, const Person& p2) {
        return (p1.m_Age < p2.m_Age);
    }
};

// 自定义数据类并集
void test02() {
    vector<Person>v1; // 有序
    vector<Person>v2; // 有序
    Person p1("A", 17);
    Person p2("B", 19);
    Person p3("C", 21);
    Person p4("D", 23);
    Person p5("E", 25);

    v1.push_back(p3);
    v1.push_back(p2);
    v1.push_back(p1);

    v2.push_back(p2);
    v2.push_back(p3);
    v2.push_back(p4);
    v2.push_back(p5);

    // 先对容器进行排序
    sort(v1.begin(), v1.end(), Person_sort());
    sort(v2.begin(), v2.end(), Person_sort());

    vector<Person>v_target; // 目标容器
    v_target.resize(v1.size() + v2.size()); // 两个容器大小和

    vector<Person>::iterator EndIt = set_union(v1.begin(), v1.end(), v2.begin(), v2.end(), v_target.begin(), Person_sort());
    for_each(v_target.begin(), EndIt, PrintVector<Person>); // 遍历
    cout << endl;
}

int main() {
    test01();
    test02();
    system("pause");
    return 0;
}

运行结果：

  •  两个集合必须是有序序列
  • 目标容器开辟空间需要两个容器相加
  • set_union 返回值是并集最后一个元素的位置

set_difference

功能：

  • 求两个集合（有序序列）的差集

差集：

  • v1 和 v2 的差集，找的是 v1 里有但 v2 里没有的元素（v1 特有的数）
  • v2 和 v1 的差集，找的是 v2 里有但 v1 里没有的元素（v2 特有的数）

函数原型：

set_difference(iterator beg1, iterator end1, iterator beg2, iterator end2, iterator dest);

beg1 —— 容器 1 开始迭代器

end1 —— 容器 1 结束迭代器

beg2 —— 容器 2 开始迭代器

end2 —— 容器 2 结束迭代器

dest  —— 目标容器开始迭代器

测试代码：

#include<iostream>
#include<algorithm>
#include<vector>
#include<string>
using namespace std;

class Person {
public:
    Person(string name, int age) :m_Name(name), m_Age(age) {}
    Person() {}
    string m_Name;
    int m_Age;
};

ostream& operator<<(ostream& cout, const Person& p) {
    cout << p.m_Name << " " << p.m_Age << endl;
    return cout;
}

template<typename T>
void PrintVector(const T& x) {
    cout << x << " ";
}

// 内置数据类型差集
void test01() {
    vector<int>v1; // 有序
    vector<int>v2; // 有序

    v1.push_back(10);
    v1.push_back(20);
    v1.push_back(30);
    v1.push_back(40);

    v2.push_back(30);
    v2.push_back(40);
    v2.push_back(50);
    v2.push_back(60);

    cout << "v1 与 v2 的差集：";
    vector<int>v_target1; // 目标容器
    v_target1.resize(max(v1.size(), v2.size())); // 容器大小
    vector<int>::iterator EndIt1 = set_difference(v1.begin(), v1.end(), v2.begin(), v2.end(), v_target1.begin());
    for_each(v_target1.begin(), EndIt1, PrintVector<int>);
    cout << endl;
    
    cout << "v1 与 v2 的差集：";
    vector<int>v_target2; // 目标容器
    v_target2.resize(max(v1.size(), v2.size())); // 容器大小
    vector<int>::iterator EndIt2 = set_difference(v2.begin(), v2.end(), v1.begin(), v1.end(), v_target2.begin());
    for_each(v_target2.begin(), EndIt2, PrintVector<int>);
    cout << endl;
}

// 年龄排序仿函数
class Person_sort {
public:
    bool operator()(const Person& p1, const Person& p2) {
        return (p1.m_Age < p2.m_Age); // m_Age 降序
    }
};

// 自定义数据类型差集
void test02() {
    vector<Person>v1; // 有序
    vector<Person>v2; // 有序

    Person p1("A", 22);
    Person p2("B", 21);
    Person p3("C", 20);
    Person p4("D", 19);
    Person p5("E", 18);

    v1.push_back(p1);
    v1.push_back(p2);
    v1.push_back(p3);

    v2.push_back(p3);
    v2.push_back(p4);
    v2.push_back(p5);

    sort(v1.begin(), v1.end(), Person_sort()); // 排序
    sort(v2.begin(), v2.end(), Person_sort()); // 排序

    cout << "v1 和 v2 的差集：" << endl;
    vector<Person>v_target1;
    v_target1.resize(max(v1.size(), v2.size()));
    vector<Person>::iterator EndIt1 = set_difference(v1.begin(), v1.end(), v2.begin(), v2.end(), v_target1.begin(), Person_sort());
    for_each(v_target1.begin(), EndIt1, PrintVector<Person>);
    cout << endl;

    cout << "v2 与 v1 的差集：" << endl;;
    vector<Person>v_target2;
    v_target2.resize(max(v1.size(), v2.size()));
    vector<Person>::iterator EndIt2 = set_difference(v2.begin(), v2.end(), v1.begin(), v1.end(), v_target2.begin(), Person_sort());
    for_each(v_target2.begin(), EndIt2, PrintVector<Person>);
    cout << endl;
}

int main() {
    test01();
    test02();
    system("pause");
    return 0;
}

运行结果：

  •  两个容器需要是有序序列
  • 目标容器开辟空间大小取两个容器中大的
集合运算（c++代码）
04-28
void SeqList::out(SeqList& A,SeqList& B)//将相同的元素放到另一个顺序表中。 { int i,j; for(i=0;i<A.size-1;i++) { for(j=i+1;jMaxListSize) exit(1); int i=0; for(i=0;i<B.size;i++) { A.data[A.size]=B.data[i]; A.size++; } }
用C++实现的集合的运算
06-21
用C++实现的集合运算（课程设计），实现交，并，补，用类实现，比较简洁。
C++常用集合算法
guicaifjz的博客
07-09 233
常用集合算法set_intersectionset_unionset_difference 学习目标： 掌握常用的集合算法 算法简介: set_intersection//求两个容器的交集 set_union//求两个容器的并集 set_difference//求两个容器的差集 set_intersection 功能描述： 求两个容器的交集 #include <iostream> using namespace std; #include <vector> #includ
c++常用集合算法
weixin_46245201的博客
09-05 727
文章目录常用集合算法算法简介set_intersection功能描述函数原型示例总结set_union功能描述函数原型示例总结set_difference功能描述函数原型示例 常用集合算法 算法简介 set_intersection 功能描述 函数原型 示例 #include<iostream> #include<vector> #include <algorithm> #include<string> using namespace std; v
C++常用集合算法实例教程及源码解析
4. 常用集合算法详解：在C++中实现的常用集合算法包括但不限于排序算法和搜索算法。排序算法如冒泡排序、快速排序、插入排序、选择排序和归并排序等，它们各自有不同的优缺点和适用场景。搜索算法如线性搜索和二分...
01 常用集合算法.rar_常用集合算法
09-23
这篇资料“01 常用集合算法.rar”显然是一个针对C++程序员的学习资源，旨在整理和归纳一系列常用的集合操作和算法。集合算法通常涉及到数据结构如数组、链表、树、图等，以及在这些结构上的操作，如查找、排序、插入...
C++ 常用经典算法代码
05-11
本文将深入探讨在C++中常用的经典算法，包括排序、搜索、高精度计算以及二叉树等相关问题。 一、排序算法 排序是计算机科学中最基础的算法之一，C++中常见的排序算法有以下几种： 1. 冒泡排序（Bubble Sort）：...
常用集合算法_C++_源码
10-02
在C++编程语言中，集合算法是数据结构与算法领域中的一个重要组成部分，它们主要用于操作和管理数据集合。这里我们将深入探讨C++中的集合算法，特别是`set_union`这个函数，它在处理数据集合并集时非常有用。 首先...
每天学点C++（C++实例教程：教程+源码）常用集合算法.zip
最新发布
06-21
本教程旨在通过实例和源码帮助你深入理解和掌握C++中的常用集合算法。以下是这些算法的一些关键点和详细说明： 1. **排序算法**： - **冒泡排序**：这是一种简单的排序算法，通过反复遍历待排序的序列，依次比较...
C++实现集合运算
weixin_51529286的博客
10-15 3571
实现集合的交、并、差运算 //老师问为啥那么少的人提前交，我做完了但是好多地方没有中文提示，就是纯代码，我就准备先不交再完善下 #include<iostream> #include<stdlib.h> //想用动态内存，但我发现直接定义足够大的静态数组比较简单，懒得写动态了 #include<stdio.h> using namespace std; //给集合赋值 void function_1(int A[100],int B[100],int &m,i
（C++)简单集合运算
05-09
本程序是运用C++数组可现简单的 集合运算 如并集，交集，差集，和笛卡尔积~~
数据结构——算法技能实训【集合运算（C++）】
Slience_Jhon的博客
01-08 731
一个很啰嗦很低级的程序 期末算法技能实训的选题，初学C++和算法，对于时间和空间复杂度的理解不是很深，但写完之后自我感觉这样的代码简直太白痴了，一个简单的集合运算居然写了一千行，不用脑子都能想到这利用率和可用性得多低了，但好歹是自己亲手打出来的，以示警戒，下次不能再整这么啰嗦的算法了。（PS：啰嗦就罗嗦在我想给程序交互界面更人性化点，所以设计了多级菜单以及返回上级菜单的功能），但这样空间代价太大了...
c++集合算法
瑞_板凳精神
03-05 162
set_ intersection交集 算法求两个set集合的交集 注意：必须是有序序列 beg1：容器1开始迭代器: end1：容器1结束迭代器 beg2：容器2开始迭代器 end2：容器2结束迭代器 dest ：目标容器开始迭代器 return：容器的最后一个元素的迭代器地址 set_intersection(iterator beg1， iterator end1, iterator beg2，iterator end2， iterator dest ) 例子： vector<int&
Visual C++常用数值算法集 源代码 何光渝
11-18
《Visual C++常用数值算法集 源代码 何光渝》是一份珍贵的资源，主要针对使用C++编程语言进行数值计算的开发者。这份源代码集合包含了多种关键的数值算法，涵盖了微分方程组求解和矩阵运算等多个领域。下面我们将...
C++常用经典算法源码
12-01
"C++常用经典算法源码"集合了多个核心算法领域的实现，对于学习和提升C++编程技能，以及深入理解算法原理极具价值。 首先，我们来看"第1章 高精度计算"。高精度计算涉及到大整数运算，通常在标准库类型无法满足精度...
C++ STL（十七）：常用集合算法（set_intersection、set_union、set_difference）
NewsomTech
03-01 2819
文章目录0 常用集合算法简介【set_intersection、set_union、set_difference】1 set_intersection【将两个容器的交集存储至新容器】2 set_union【将两个容器的并集存储至新容器】3 set_difference【将两个容器的差集存储至新容器】 0 常用集合算法简介【set_intersection、set_union、set_difference】 算法简介： set_intersection：将两个容器的交集存储至新容器。 set_union：
C++实现简易的集合运算
m0_51574586的博客
12-26 2687
C++实现简易集合运算
C++实现集合运算.cpp
09-14
注释清楚详细，代码运行无误。小白学习专用
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值