#include <bits/stdc++.h>
using namespace std;
#define LL long long
#define ElemType int // 算是泛化吧

//!!!UTF-8!!!

/*
   使用顺序表存储集合，
   并实现集合的交集、并集、差集（即A-B）、对称差（即A-B并B-A）、
   判断一个元素是否属于一个集合、判断两个集合是否相等。

   计算机科学中，集合是一组可变数量的数据项(也可能是0个)的组合，
   这些数据项可能共享某些特征，需要以某种操作方式一起进行操作。
   一般来讲，这些数据项的类型是相同的，或基类相同(若使用的语言支持继承)。
   列表(或数组)通常不被认为是集合，因为其大小固定，但事实上它常常在实现中作为某些形式的集合使用。
   集合的种类包括列表，集，多重集，树和图。枚举类型可以是列表或集。

   集合论中，设A，B是两个集合，由所有属于集合A且属于集合B的元素所组成的集合，
   叫做集合A与集合B的交集（intersection），记作A∩B。

   一般地，设A，B是两个集合，由所有属于A且不属于B的元素组成的集合，
   叫做集合A减集合B(或集合A与集合B之差)，类似地，对于集合A.B，
   我们把集合{x/x∈A,且x￠B}叫做A与B的差集，记作A－B记作A－B(或A\B)，即A－B＝{x|x∈A，且x
 */

struct SqList {
		int len=0,size=0;
		ElemType *pData;
		void Create(int Size)
		{
				size = Size;
				pData=new ElemType[size];
				len = 0;
		}
		void Delete(int pos)
		{
				len--;
				for(int i=pos; i<len-1; i++)
						pData[i]=pData[i+1];
		}
		void Destroy()
		{
				size=len=0;
				delete pData; // delete自身会自动检查对象是否为空.如果为空,就不做操作...
				pData = nullptr;
		}
		void Insert(ElemType Data,int pos)
		{
				if(len==size)
				{
						size +=100;
						pData=(ElemType*)realloc(pData,sizeof(pData)+100*sizeof(ElemType));
				}

				for(int i=len-1; i>=pos; i--)
						pData[i+1]=pData[i];
				pData[pos]=Data;
				len++;
		}
		void Cout()
		{
				for(int i=0; i<len; i++)
						cout<<pData[i]<<" ";
		}
};




struct Range {
		int start,end;
		Range(int s=0,int e=0) // 成员函数
		{
				start = s,end = e;
		}
};

template <typename T> // 泛化

void q_sort(T arr[],const int len) // 迭代法
{
		if(len<=0) return; // 防止堆叠阵列卡死
		Range r[len]; // 用 r[] 做模拟堆叠
		int p = 0; // p 做数量，r[p++] 为 push , r[--p]为pop
		r[p++] = Range(0,len-1);
		while(p)
		{
				Range range = r[--p];
				if(range.start >= range.end) continue;
				T mid = arr[range.end];
				int left = range.start,right = range.end - 1;
				while(left < right)
				{
						while(arr[left] < mid && left < right) left++;
						while(arr[right] >= mid && left < right) right--;
						swap(arr[left],arr[right]);
				}
				if(arr[left] >= arr[range.end])
						swap(arr[left], arr[range.end]);
				else
						left++;
				r[p++] = Range(range.start,left - 1);
				r[p++] = Range(left + 1,range.end);
		}
}

ElemType *Jiaoji(ElemType a[],int alen,ElemType b[],int blen)
{
		if(alen>blen);
		else swap(a,b),swap(alen,blen);
		bool pd[1008611];
		ElemType *ans;
		ans = new ElemType[alen];
		int num=1;
		for(int i=0; i<alen; i++)
				for(int j=i; j<blen; j++)
						if(a[i]==b[j]&&!pd[a[i]])
						{
								ans[num++]= a[i];
								pd[a[i]]=1;
						}
		ans[0] = num; // 存储长度信息
		return ans;
}

ElemType *Bingji(ElemType a[],int alen,ElemType b[],int blen)
{
		int len = alen+blen,num=1;
		ElemType *ans = new ElemType[len];
		bool pd[1008611];
		memset(pd,0,sizeof(pd));
		for(int i=0; i<alen; i++)
				if(!pd[a[i]%1008611])
				{
						ans[num++]=a[i];
						pd[a[i]%1008611]=true;
				}
		for(int i=0; i<blen; i++)
				if(!pd[b[i]%1008611])
				{
						ans[num++]=b[i];
						pd[b[i]%1008611]=true;
				}
		ans[0] = num;
		return ans;
}

ElemType *Chaji(ElemType a[],int alen,ElemType b[],int blen)
{
		int len = max(alen,blen),num=1;
		ElemType *ans = new ElemType[len];
		bool pd[1008611];
		memset(pd,0,sizeof(pd));
		for(int i=0; i<alen; i++)
				if(!pd[a[i]%1008611])
						pd[a[i]%1008611]=true;
		for(int i=0; i<blen; i++)
				if(!pd[b[i]%1008611])
						pd[b[i]%1008611]=false;

		for(int i=0; i<alen; i++)
				if(pd[a[i]%1008611])
						ans[num++] = a[i];
		ans[0] = num;
		return ans;
}

ElemType *Duichencha(ElemType a[],int alen,ElemType b[],int blen)
{
		int len = alen+blen,num=1;
		ElemType *ans = new ElemType[len];
		bool pdA[1008611],pdB[1008611];

		for(int i=0; i<alen; i++)
				if(!pdA[a[i]%1008611])
						pdA[a[i]%1008611]=true;
		for(int i=0; i<blen; i++)
				if(!pdA[b[i]%1008611])
						pdA[b[i]%1008611]=false;
		for(int i=0; i<alen; i++)
				if(pdA[a[i]%1008611])
						ans[num++] = a[i];

		for(int i=0; i<alen; i++)
				if(!pdB[b[i]%1008611])
						pdB[b[i]%1008611]=true;
		for(int i=0; i<blen; i++)
				if(!pdB[a[i]%1008611])
						pdB[a[i]%1008611]=false;
		for(int i=0; i<alen; i++)
				if(pdB[b[i]%1008611])
						ans[num++] = b[i];

		ans[0] = num;
		return ans;
}

bool PdShuyu(ElemType a[],int alen,ElemType b) // 判断元素 b 是否属于集合 a
{
		for(int i=0; i<alen; i++)
				if(a[i]==b)
						return true;
		return false;
}

bool PdJiheXiangdeng(ElemType a[],int alen,ElemType b[],int blen)
{
		if(alen!=blen) return false;
		for(int i=0; i<alen; i++)
				if(a[i]!=b[i]) return false;
		return true;
}

int main()
{
//不说元素类型，泛式太麻烦，就用整形了
		int aa[9] = {1,2,3,4,5,6,7,8,9}; // 用于测试数据填充
		int bb[9] = {10,11,2,4,6,8,37,4,5};
		SqList a,b;
		a.Create(5);
		b.Create(5);
		for(int i=0; i<9; i++)
		{
				a.Insert(aa[i],i);
				b.Insert(bb[i],i);
		}

		cout <<"The original data of A "; a.Cout(); cout << endl;
		cout <<"The original data of B "; b.Cout(); cout << endl;

//为了方便，先对数据处理（就是想复习快排了
		q_sort(a.pData,a.len);
		q_sort(b.pData,b.len);

		cout <<"Sorted data of A "; a.Cout(); cout << endl;
		cout <<"Sorted data of B "; b.Cout(); cout << endl;

		cout << "Intersection: ";
		ElemType *jiaoji = Jiaoji(a.pData,a.len,b.pData,b.len);
		for(int i=1; i<jiaoji[0]; i++)
				cout << jiaoji[i]<<" ";
		cout << endl;

		// a.Cout(),cout << endl;
		// b.Cout(),cout << endl;

		cout << "Union: ";
		ElemType *bingji = Bingji(a.pData,a.len,b.pData,b.len);
		for(int i=1; i<bingji[0]; i++)
				cout << bingji[i]<<" ";
		cout << endl;

		cout << "Subtraction: ";
		ElemType *chaji = Chaji(a.pData,a.len,b.pData,b.len);
		for(int i=1; i<chaji[0]; i++)
				cout << chaji[i]<<" ";
		cout << endl;

		cout << "Symmetrical difference: ";
		ElemType *duichencha = Duichencha(a.pData,a.len,b.pData,b.len);
		for(int i=1; i<duichencha[0]; i++)
				cout << duichencha[i]<<" ";
		cout << endl;

		cout << "Determine whether an element belongs to a collection";
		cout << endl << "Element is 9" << "     " <<"Set as A "<< endl;
		if(PdShuyu(a.pData,a.len,9))
				cout << "Belong";
		else cout << "Not Belong";
		cout << endl;

		cout << "Determine whether two sets are equal"<<endl;
		if(PdJiheXiangdeng(a.pData,a.len,b.pData,b.len))
				cout << "Equal";
		else cout <<  "Not Equal";
		cout << endl;

		return 0;
}

虽然应该写写解析,但太麻烦了,而且,也不是什么难题单纯耗费时间罢了,所以就算了吧