【id:318】【25分】C. 集合（输出/算术运算符重载）

题目描述

集合是由一个或多个确定的元素所构成的整体。集合的运算有并、交、相对补等。

集合A和集合B的交集：由属于A且属于B的相同元素组成的集合。

集合A和集合B的并集：由所有属于集合A或属于集合B的元素所组成的集合。

集合B关于集合A的相对补集，记做A-B：由属于A而不属于B的元素组成的集合。

假设集合A={10，20，30}，集合B={1，10，50，8}。则A与B的并是{10，20，30,1,50,8}，A与B的交是{10}，B关于A的相对补集是{20,30}。

定义整数集合类CSet，属性包括：集合中的元素个数n，整型指针data存储集合中的元素。

方法有：重载输出，按样例格式输出集合中的元素。

重载+运算符，求集合A和集合B的并集，并返回结果集合。

重载-运算符，求集合B关于集合A的相对补集，并返回结果集合。

重载*运算符，求集合A和集合B的交集，并返回结果集合。

主函数输入集合A、B的数据，计算集合的并、交、相对补。

可根据题目，为CSet类添加需要的成员函数。

输入

测试次数

每组测试数据两行，格式如下：

第一行：集合A的元素个数和元素

第二行：集合B的元素个数和元素

输出

每组测试数据输出如下：

第一行：集合A

第二行：集合B

第三行：A和B的并

第四行：A和B的交

第五行：B关于A的相对补集 与 A关于B的相对补集的并，即(A-B)+(B-A)

每组测试数据间以空行分隔。

输入

2
3 10 20 30
4 10 1 2 3
5 100 2 3 4 -10
6 -34 12 2 4 90 100
 

输出

A:10 20 30
B:10 1 2 3
A+B:10 20 30 1 2 3
A*B:10
(A-B)+(B-A):20 30 1 2 3

A:100 2 3 4 -10
B:-34 12 2 4 90 100
A+B:100 2 3 4 -10 -34 12 90
A*B:100 2 4
(A-B)+(B-A):3 -10 -34 12 90

 

#include <iostream>
#include <vector>
#include <algorithm>
#include <iterator>

using namespace std;

class CSet {
private:
    int n;
    int* data;

public:

    CSet(int numElements, int* elements) : n(numElements) {
        data = new int[n];
        for (int i = 0; i < n; ++i) {
            data[i] = elements[i];
        }
    }


    ~CSet() {
        delete[] data;
    }


    friend ostream& operator<<(ostream& os, const CSet& set) {

        for (int i = 0; i < set.n; ++i) {
            if (i != 0)
                os << " ";
            os << set.data[i];
        }
        return os;
    }


    CSet operator+(const CSet& other) const {
        vector<int> result;
        result.insert(result.end(), data, data + n);
        for (int i = 0; i < other.n; ++i) {
            if (find(data, data + n, other.data[i]) == data + n) {
                result.push_back(other.data[i]);
            }
        }

        int* resultData = new int[result.size()];
        copy(result.begin(), result.end(), resultData);
        return CSet(result.size(), resultData);
    }

    CSet operator-(const CSet& other) const {
        vector<int> result;
        for (int i = 0; i < n; ++i) {
            if (find(other.data, other.data + other.n, data[i]) == other.data + other.n) {
                result.push_back(data[i]);
            }
        }

        int* resultData = new int[result.size()];
        copy(result.begin(), result.end(), resultData);
        return CSet(result.size(), resultData);
    }


    CSet operator*(const CSet& other) const {
        vector<int> result;
        for (int i = 0; i < n; ++i) {
            if (find(other.data, other.data + other.n, data[i]) != other.data + other.n) {
                result.push_back(data[i]);
            }
        }

        int* resultData = new int[result.size()];
        copy(result.begin(), result.end(), resultData);
        return CSet(result.size(), resultData);
    }
};

int main() {
    int numTests;
    cin >> numTests;
    cin.ignore();

    for (int t = 0; t < numTests; ++t) {

        int sizeA;
        cin >> sizeA;
        int* elementsA = new int[sizeA];
        for (int i = 0; i < sizeA; ++i) {
            cin >> elementsA[i];
        }
        CSet setA(sizeA, elementsA);


        int sizeB;
        cin >> sizeB;
        int* elementsB = new int[sizeB];
        for (int i = 0; i < sizeB; ++i) {
            cin >> elementsB[i];
        }
        CSet setB(sizeB, elementsB);

        cout << "A:"<<setA << endl;
        cout << "B:"<<setB << endl;
        cout << "A+B:" << (setA + setB) << endl;
        cout << "A*B:" << (setA * setB) << endl;

        CSet relativeComplementAB = setB - setA;
        CSet relativeComplementBA = setA - setB;
        cout << "(A-B)+(B-A):" << (relativeComplementBA + relativeComplementAB) << endl;


        if (t < numTests - 1) {
            cout << endl;
        }

        delete[] elementsA;
        delete[] elementsB;
    }

    return 0;
}