数据结构C++实现顺序表实现集合操作：交集并集与差集

Posted 2021-12-09 u25th_engineer

  （递增有序）顺序表表示集合A、B，实现以下操作：

  
$$C=A\cap B，C=A\cup B，C=A\setminus B$$
$$A=A\cap B，A=A\cup B，A=A\setminus B$$

  完整类声明、实现与测试见：数据结构实验1：C++实现静态顺序表类

• $C=A\cap B$

bool SeqList::intersectionSet( SeqList& LA, SeqList& LB, SeqList& LC )
{
	int ia, ib;
	if( LA.isEmpty() || LB.isEmpty() )
	{
		cout << "Insert failed!\\nAt least one Sequence list is empty!" << endl;
		return false;
	}
	for( ia = 0, ib = 0; ia < LA.listSize, ib < LB.listSize; )
	{
		if( ia == LA.listSize - 1 || ib == LB.listSize - 1 )
			//break;
			return true;
		if( LA.Arr[ia] == LB.Arr[ib] )
		{
			LC.insertListRear( LB.Arr[ib] );
			ia ++;
			ib ++;
		}
		else if( LA.Arr[ia] < LB.Arr[ib] )
		{
			ia ++;
			continue;
		}
		else 
		{
			ib ++;
			continue;
		}
	}
	return true;
}

• $C=A\cup B$

bool SeqList::unionSet( SeqList& LA, SeqList& LB, SeqList& LC )
{
	// 我设置的条件是：求交集、并集和差集要求两个集合均非空，与数学上的理论情况不同。
	if( LA.isEmpty() || LB.isEmpty() )
	{
		cout << "Insert failed!\\nAt least one sequence list is empty!" << endl;
		return false;
	}
	int i = 0, j = 0;
	while( i < LA.listSize && j < LB.listSize )
	{
		if( LA.Arr[i] == LB.Arr[j] )
		{
			LC.insertListRear( LA.Arr[i] );
			//LC.insertListRear( LB.Arr[j] );
			i ++;
			j ++;
		}
		else if( LA.Arr[i] < LB.Arr[j] )
		{
			LC.insertListRear( LA.Arr[i] );
			i ++;
		}
		else if( LA.Arr[i] > LB.Arr[j] )
		{
			LC.insertListRear( LB.Arr[j] );
			j ++;
		}
	}
	while( i <  LA.listSize )
	{
		LC.insertListRear( LA.Arr[i] );
		i ++;
	}
	while( j <  LB.listSize )
	{
		LC.insertListRear( LB.Arr[j] );
		j ++;
	}
	return true;
}

• $C=A\setminus B$

bool SeqList::subTractSet( SeqList& LA, SeqList& LB, SeqList& LC )
{
	// 我设置的条件是：求交集、并集和差集要求两个集合均非空，与数学上的理论情况不同。
	if( LA.isEmpty() || LB.isEmpty() )
	{
		cout << "Insert failed!\\nAt least one sequence list is empty!" << endl;
		return false;
	}
	if( LA.listSize < LB.listSize )
	{
		cerr << "Invalid operation(C = A - B)." << endl << 
		"The size of sequence list A(" << LA.listSize << 
		") is smaller than the size of sequence list B(" << LB.listSize << ")." << endl;
		return false;
	}
	for( int i = 0; i < LA.listSize; i ++ ) 
	{ 
		int j = 0; 
		while( j < LB.listSize && LB.Arr[j] != LA.Arr[i] ) 
			j ++; 
		if( j == LB.listSize ) //表示A->data[i]不在B中，将其放到C中 
			//C->data[ k++]=A->data[i];
			LC.insertListRear( LA.Arr[i] );
	}
	return true;
}

• $A=A\cap B$

bool SeqList::intersectionSet( SeqList& LA, SeqList& LB )
{
	// 我设置的条件是：求交集、并集和差集要求两个集合均非空，与数学上的理论情况不同。
	if( LA.isEmpty() || LB.isEmpty() )
	{
		cout << "Insert failed!\\nAt least one sequence list is empty!" << endl;
		return false;
	}
	int i = 0, j = 0, k = 0, tot = 0;
	while( i < LA.listSize && j < LB.listSize )
	{
		if( LA.Arr[i] == LB.Arr[j] )
		{
			LA.Arr[ i - k ] = LA.Arr[i];
			i ++;
			j ++;
			tot ++;
		}
		else if( LA.Arr[i] < LB.Arr[j] )
		{
			i ++;
			k ++;
		}
		else
		{
			j ++;
		}
	}
	LA.listSize = tot;
	return true;
}

• $A=A\cup B$

bool SeqList::unionSet( SeqList& LA, SeqList& LB )
{
	// 我设置的条件是：求交集、并集和差集要求两个集合均非空，与数学上的理论情况不同。
	if( LA.isEmpty() || LB.isEmpty() )
	{
		cout << "Insert failed!\\nAt least one sequence list is empty!" << endl;
		return false;
	}
	int i = LA.listSize - 1, j = LB.listSize - 1;
    int k = LA.listSize + LB.listSize - 1;
	LA.listSize = k + 1;
    while( i >= 0 && j >= 0  && k >= 0 )
    {
        if( LB.Arr[j] > LA.Arr[i] )
        {
            LA.Arr[k] = LB.Arr[j];
            k --;
            j --;
        }
        else
        {
            LA.Arr[k] = LA.Arr[i];
            k --;
            i --;
        }
    }
    while( i >= 0 )
    {
        LA.Arr[ k -- ] = LA.Arr[ i -- ];
    }
    while( j >= 0 )
    {
        LA.Arr[ k -- ] = LB.Arr[ j -- ];
    }
	return true;
}

• $A=A\setminus B$

bool SeqList::subTractSet( SeqList& LA, SeqList& LB )
{
	// 我设置的条件是：求交集、并集和差集要求两个集合均非空，与数学上的理论情况不同。
	if( LA.isEmpty() || LB.isEmpty() )
	{
		cerr << "Insert failed!\\nAt least one sequence list is empty!" << endl;
		return false;
	}
	if( LA.listSize < LB.listSize )
	{
		cerr << "Invalid operation(A = A - B)." << endl << 
		"The size of sequence list A(" << LA.listSize << 
		") is smaller than the size of sequence list B(" << LB.listSize << ")." << endl;
		return false;
	}
	int i = 0, j = 0, k = 0, tot = 0;
	while( i < LA.listSize && j < LB.listSize )
	{
		if( LA.Arr[i] == LB.Arr[j] )
		{
			i ++;
			j ++;
			k ++;
		}
		else if( LA.Arr[i] < LB.Arr[j] )
		{
			LA.Arr[ i - k ] = LA.Arr[i];
			i ++;
			tot ++;
		}
		else
		{
			j ++;
		}
	}
	while( i < LA.listSize )
	{
		LA.Arr[ i - k ] = LA.Arr[i];
		i ++;
		k ++;
		tot ++;
	}
	LA.listSize = tot;
	return true;
}