集合（运算符重载）

题目描述

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

集合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)

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

输入样例1 

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

输出样例1

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

思路分析

先讲一下算法：

集合之间的运算，咋一看起来还是比较困难的，有并集、交集、补集，我想了一下，交集应该相对比较好算，我的想法是，先两个循环比较两个集合的元素，找出相同的元素数目，把这个交集的集合数目先确定下来，然后可以开辟集合对象，这样就避免来开大数组，集合对象有了之后，再来两个循环找相同的元素，把相同的元素装进我们的交集集合对象，交集完事。

并集怎么思考呢？其实两个集合并集的元素数目就等于两个集合的元素数目之和减去它们的交集元素数目，而我们刚刚把交集的搞定了，于是并集的元素数目可以确定下来，然后开辟集合对象，先拷贝前一个集合的所有元素，然后两个循环找出后一个集合中没有在前一个集合中出现的元素，然后将这个元素装进并集集合，并集完事。

B关于A的补集，即A-B，就是A的集合元素减去A和B的交集元素，这样，我们就可以把补集的元素数据确定下来，然后开辟集合对象，两个循环找出A中没有在B中出现的元素，装进补集，补集完事。

再讲一下语法：

我第一次的代码写了下面这个析构函数，然后呢后来的C，就是A+B之类的没有空间，一开始以为是没有重载赋值运算符的问题，然后就把析构函数去掉了，就是下面的代码1，这样也能过。

后来就是再思考的时候，发现只要在拷贝构造函数参数前面加上const就不会出现上述问题，而且在重载运算符的参数处加上了const，然后就把后面引入的C和D给删了，直接通过a和b的组合输出。

    ~CSet()
    {
        if (data)
            delete data;
        data = NULL;
    }

后来再次思考，发现代码1这种写法是不太好的，如果加上析构函数，还是不行，必须重载等号运算符。 

AC代码1

#include <iostream>
using namespace std;
class CSet
{
	int n, * data = NULL;
public:
	CSet(int n) :n(n)
	{
		data = new int[n];
	}
	CSet() {}
	CSet(CSet& set)
	{
		if (data == NULL)
			data = new int[n];
		int i;
		for (i = 0; i < n; i++)
			data[i] = set.data[i];
	}
	void datain()
	{
		int i;
		for (i = 0; i < n; i++)
			cin >> data[i];
	}
	CSet operator+(CSet& set)
	{
		int num = 0, i, j, k = n, tag;
		for (i = 0; i < n; i++)
			for (j = 0; j < set.n; j++)
				if (data[i] == set.data[j])
				{
					num++;
					break;
				}
		CSet c(n + set.n - num);
		for (i = 0; i < n; i++)
			c.data[i] = data[i];
		for (i = 0; i < set.n; i++)
		{
			tag = 0;
			for (j = 0; j < n; j++)
				if (set.data[i] == data[j])
				{
					tag = 1;
					break;
				}
			if (tag == 0)
				c.data[k++] = set.data[i];
		}
		return c;
	}
	CSet operator-(CSet& set)
	{
		int num = 0, i, j, k = 0, tag;
		for (i = 0; i < n; i++)
			for (j = 0; j < set.n; j++)
				if (data[i] == set.data[j])
				{
					num++;
					break;
				}
		CSet c(n - num);
		for (i = 0; i < n; i++)
		{
			tag = 0;
			for (j = 0; j < set.n; j++)
				if (data[i] == set.data[j])
				{
					tag = 1;
					break;
				}
			if (tag == 0)
				c.data[k++] = data[i];
		}
		return c;
	}
	CSet operator*(CSet& set)
	{
		int num = 0, i, j, k = 0;
		for (i = 0; i < n; i++)
			for (j = 0; j < set.n; j++)
				if (data[i] == set.data[j])
				{
					num++;
					break;
				}
		CSet c(num);
		for (i = 0; i < n; i++)
			for (j = 0; j < set.n; j++)
				if (data[i] == set.data[j])
				{
					c.data[k++] = data[i];
					break;
				}
		return c;
	}
	friend ostream& operator<<(ostream& out, CSet& set);
};
ostream& operator<<(ostream& out, CSet& set)
{
	int i;
	for (i = 0; i < set.n - 1; i++)
		out << set.data[i] << ' ';
	out << set.data[i] << endl;
	return out;
}
int main()
{
	int t, n;
	cin >> t;
	while (t--)
	{
		cin >> n;
		CSet a(n);
		a.datain();

		cin >> n;
		CSet b(n);
		b.datain();
		cout << "A:" << a << "B:" << b;
		CSet c, d;
		c = a + b;
		cout << "A+B:" << c;

		c = a * b;
		cout << "A*B:" << c;
		c = a - b;
		d = b - a;
		c = c + d;
		cout << "(A-B)+(B-A):" << c << endl;;
	}

	return 0;
}

AC代码2(推荐）

#include <iostream>
using namespace std;
class CSet
{
	int n, * data = NULL;
public:
	CSet(int n) :n(n)
	{
		data = new int[n];
	}
	CSet() {}
	CSet(const CSet& set)
	{
		if (data == NULL)
			data = new int[n];
		int i;
		for (i = 0; i < n; i++)
			data[i] = set.data[i];
	}
	~CSet()
	{
		if(data)
		delete[] data;
		data=NULL;
	}
	void datain()
	{
		int i;
		for (i = 0; i < n; i++)
			cin >> data[i];
	}
	CSet operator+(const CSet& set)
	{
		int num = 0, i, j, k = n, tag;
		for (i = 0; i < n; i++)
			for (j = 0; j < set.n; j++)
				if (data[i] == set.data[j])
				{
					num++;
					break;
				}
		CSet c(n + set.n - num);
		for (i = 0; i < n; i++)
			c.data[i] = data[i];
		for (i = 0; i < set.n; i++)
		{
			tag = 0;
			for (j = 0; j < n; j++)
				if (set.data[i] == data[j])
				{
					tag = 1;
					break;
				}
			if (tag == 0)
				c.data[k++] = set.data[i];
		}
		return c;
	}
	CSet operator-(const CSet& set)
	{
		int num = 0, i, j, k = 0, tag;
		for (i = 0; i < n; i++)
			for (j = 0; j < set.n; j++)
				if (data[i] == set.data[j])
				{
					num++;
					break;
				}
		CSet c(n - num);
		for (i = 0; i < n; i++)
		{
			tag = 0;
			for (j = 0; j < set.n; j++)
				if (data[i] == set.data[j])
				{
					tag = 1;
					break;
				}
			if (tag == 0)
				c.data[k++] = data[i];
		}
		return c;
	}
	CSet operator*(CSet& set)
	{
		int num = 0, i, j, k = 0;
		for (i = 0; i < n; i++)
			for (j = 0; j < set.n; j++)
				if (data[i] == set.data[j])
				{
					num++;
					break;
				}
		CSet c(num);
		for (i = 0; i < n; i++)
			for (j = 0; j < set.n; j++)
				if (data[i] == set.data[j])
				{
					c.data[k++] = data[i];
					break;
				}
		return c;
	}
	friend ostream& operator<<(ostream& out,const CSet& set);
};
ostream& operator<<(ostream& out,const CSet& set)
{
	int i;
	for (i = 0; i < set.n - 1; i++)
		out << set.data[i] << ' ';
	out << set.data[i] << endl;
	return out;
}
int main()
{
	int t, n;
	cin >> t;
	while (t--)
	{
		cin >> n;
		CSet a(n);
		a.datain();
		cin >> n;
		CSet b(n);
		b.datain();
		cout << "A:" << a << "B:" << b;
		cout << "A+B:" << a+b;
		cout << "A*B:" << a*b;
		cout << "(A-B)+(B-A):" << (a-b)+(b-a) << endl;;
	}
	return 0;
}