c++集合的交并集运算代码

下面是 Python 中集合的交、并、差、对称差等运算的代码示例：
a = {1, 2, 3, 4, 5}
b = {3, 4, 5, 6, 7}

# 求交集
intersection = a & b
print("a 和 b 的交集为：", intersection)

# 求并集
union = a | b
print("a 和 b 的并集为：", union)

# 求差集
difference = a - b
print("a 和 b 的差集为：", difference)

# 求对称差集
symmetric_difference = a ^ b
print("a 和 b 的对称差集为：", symmetric_difference)
登录后复制
输出结果：
a 和 b 的交集为： {3, 4, 5}
a 和 b 的并集为： {1, 2, 3, 4, 5, 6, 7}
a 和 b 的差集为： {1, 2}
a 和 b 的对称差集为： {1, 2, 6, 7}
登录后复制

相关问题

写一个c++程序，用顺序表实现集合的并集运算

在C++中，我们可以使用顺序表（如数组或者vector）来实现集合的并集运算。这里是一个简单的示例，我们将使用std::vector来存储元素，并利用insert函数将元素添加到已有的集合中：
#include <iostream>
#include <vector>

// 集合的简单表示，使用整数作为元素
class Set {
private:
std::vector<int> elements;

public:
// 添加元素到集合中
void add(int value) {
if (elements.find(value) == elements.end()) {
elements.push_back(value);
}
}

// 计算两个集合的并集
void merge(const Set&amp; other_set) {
for (const auto&amp; value : other_set.elements) {
add(value);
}
}

// 打印集合内容
void print() const {
for (int value : elements) {
std::cout << value << " ";
}
std::cout << "\n";
}
};

int main() {
Set set1;
set1.add(1);
set1.add(2);
set1.add(3);

Set set2;
set2.add(4);
set2.add(5);
set2.add(6);

// 合并set1和set2
set1.merge(set2);

// 打印合并后的集合
set1.print();

return 0;
}
登录后复制
在这个例子中，我们首先创建了两个Set实例，然后分别向它们添加一些元素。merge函数接收另一个集合，并将其中的所有元素添加到当前集合中。最后，我们打印出合并后的结果。

c++采用链式存储结构实现两集合的并集、交集、差集运算代码

C++中可以使用链表数据结构（如std::list）来实现不固定大小的集合，并通过指针连接元素来表示集合中的元素。这里是一个简单的例子，我们将创建两个Set类，分别使用std::list作为底层存储结构，来实现并集、交集和差集的操作：
#include <iostream>
#include <list>

template <typename T>
class Set {
private:
std::list<T> elements;
public:
// 添加元素
void insert(T value) {
elements.push_back(value);
}

// 查看是否包含元素
bool contains(const T&amp; value) const {
return std::find(elements.begin(), elements.end(), value) != elements.end();
}

// 并集操作
friend Set<T> union_set(const Set<T>&amp; set1, const Set<T>&amp; set2) {
Set<T> result(set1);
for (const auto&amp; element : set2) {
if (!result.contains(element)) {
result.insert(element);
}
}
return result;
}

// 交集操作
friend Set<T> intersection(const Set<T>&amp; set1, const Set<T>&amp; set2) {
Set<T> result;
for (const auto&amp; element : set1) {
if (set2.contains(element)) {
result.insert(element);
}
}
return result;
}

// 差集操作
friend Set<T> difference(const Set<T>&amp; set1, const Set<T>&amp; set2) {
Set<T> result(set1);
for (auto it = set2.begin(); it != set2.end();) {
if (result.contains(*it)) {
it = set2.erase(it);
} else {
++it;
}
}
return result;
}
};

// 示例
int main() {
Set<int> s1 = {1, 2, 3};
Set<int> s2 = {2, 4, 5};

Set<int> unionResult = union_set(s1, s2); // [1, 2, 3, 4, 5]
Set<int> intersectResult = intersection(s1, s2); // [2]
Set<int> diffResult = difference(s1, s2); // [1, 3]

// 打印结果
std::cout << "Union: ";
for (const auto&amp; elem : unionResult.elements) {
std::cout << elem << " ";
}
std::cout << "\nIntersection: ";
for (const auto&amp; elem : intersectResult.elements) {
std::cout << elem << " ";
}
std::cout << "\nDifference: ";
for (const auto&amp; elem : diffResult.elements) {
std::cout << elem << " ";
}
std::cout << "\n";

return 0;
}
登录后复制
这个示例展示了如何通过链式存储结构实现基本的集合操作。注意这只是一个简化版本，实际应用中可能需要添加更多的错误检查和性能优化。