C ++ realiza el conjunto de unión e intersección de dos conjuntos de tabla de secuencia

Dadas dos tablas de secuencia (que representan dos conjuntos diferentes), use las operaciones básicas de las tablas de secuencia para realizar la unión, la intersección y la diferencia de estos dos conjuntos.

El resultado de la ejecución se muestra en la siguiente figura:

He hablado sobre las operaciones básicas de la tabla de secuencias en otro artículo. No entraré en detalles sobre las operaciones básicas de la tabla de secuencias aquí. Principalmente hablo sobre cómo usar la tabla de secuencias para realizar la colección.

Nota: Debido a que los elementos de la colección son letras, ElemType es de tipo char;

           Si los elementos de la colección son números, ElemType debe cambiarse a tipo int.

#include <iostream.h>
#define MaxSize 100
typedef char ElemType;

typedef struct 
{
	ElemType data[MaxSize];
   	int length;
} SqList;   //定义线性表结构体类型 

void InitList(SqList *&L)   //引用型指针
{
	L= new SqList;
            /*分配存放线性表的空间*/
    L->length=0;
}

//1.建立一个线性表
void CreateList(SqList *&L,ElemType a[],int n)  
{
	int i;
	for (i=0;i<n;i++)
		L->data[i]=a[i];
	L->length=n;
}

//2.销毁线性表
void DestroyList(SqList *&L)
{
	delete L;
}

//3.判定是否为空表
int ListEmpty(SqList *L)
{
	return(L->length==0);
}

//4.求线性表的长度
int ListLength(SqList *L)
{
	return(L->length);
}

//5.输出线性表
void DispList(SqList *L)
{
	if (ListEmpty(L))
		return;
	for (int i=0;i<L->length;i++)
		cout<<L->data[i]<<"   ";
	cout<<endl;
} 

//6.求某个数据元素值GetElem(L,i,e)
int GetElem(SqList *L,int i,ElemType &e)
{
	if (i<1 || i>L->length) 
		return 0;
	e=L->data[i-1];
	return 1;
}

//7.按元素值查找
int LocateElem(SqList *L, ElemType e)
{
	int i=0;
	while (i<L->length && L->data[i]!=e) 
		i++;
	if (i>=L->length)
		return 0;
	else 
		return i+1;
}

//8.插入数据元素
int ListInsert(SqList *&L,int i,ElemType e)
{
	int j;
    if (i<1 || i>L->length+1)
		return 0;
    i--;  /*将顺序表逻辑位序转化为elem下标即物理位序*/
    for (j=L->length;j>i;j--)/*将data[i]及后面元素后移一个位置*/
		L->data[j]=L->data[j-1];
                
	L->data[i]=e;   //将新元素插入该位置
	L->length++;      /*顺序表长度增1*/
	return 1;
}

//9.删除数据元素
int ListDelete(SqList *&L,int i,ElemType &e)
{
     int j;
     if (i<1 || i>L->length)	return 0;
     i--;	   /*将顺序表逻辑位序转化为elem下标即物理位序*/
     e=L->data[i];
     for (j=i;j<L->length-1;j++) L->data[j]=L->data[j+1];
            /*将data[i]之后的元素前移一个位置*/
     L->length--;	/*顺序表长度减1*/
     return 1;
}

Unión

Inserte todos los elementos de LA en LC (también puede usar la función CreateList), y luego necesita filtrar los elementos que LA no tiene en LB.

El núcleo entiende el significado de if (!LocateElem(LA, e)), es decir, si e (elemento de LB) no se encuentra en LA, inserte e (elemento de LB) en LC. Por el contrario, si es encuentra en LA e , no puede insertar e en el LC.

Nota: distingue la diferencia entre ++lena y lena++

//求两顺序表的并
void unionList(SqList *LA,SqList *LB,SqList *&LC) 
{
	int lena,i;
	ElemType e;
	InitList(LC);
	for (i=1;i<=ListLength(LA);i++)	
             /*将LA的所有元素插入到Lc中*/
	{
		GetElem(LA,i,e);
		ListInsert(LC,i,e);
	}
	lena=ListLength(LA);  /*求线性表的长度*/
	int lenb=ListLength(LB);   
	for (i=1;i<=lenb;i++) 
	{	
		GetElem(LB,i,e);
		/*取LB中第i个数据元素赋给e*/
		if  (!LocateElem(LA,e)) 
			ListInsert(LC,++lena,e); 	
                 /*LA中不存在和e相同者,则插入到LC中*/
	}
} 

intersección

LC es una lista vacía, porque la longitud de LB es mayor que la de LA, para evitar que falten elementos, expanda el bucle for con LB.

El núcleo entiende el significado de if (LocateElem(LA, e)), es decir, si e (elemento de LB) se encuentra en LA, entonces e (elemento de LB) se insertará en LC. Por el contrario, si e no se encuentra en LA, entonces e no se puede insertar en LC.

//求两顺序表的交
void InterList(SqList *LA,SqList *LB,SqList *&LC) 
{
	
	int j=0;ElemType e;   
	for (int i=1;i<=ListLength(LB);i++) 
	{	
		GetElem(LB,i,e);
		/*取LB中第i个数据元素赋给e*/
		if  (LocateElem(LA,e)) 
			ListInsert(LC,++j,e); 	
                 /*LA中存在和e相同者,则插入到LC中*/
	}
} 

conjunto de diferencias

En la operación de diferencia de conjuntos, los elementos comunes de los dos conjuntos se cancelarán entre sí, por lo que de acuerdo con esta característica, es necesario encontrar elementos en LB que sean diferentes de LA.

La comprensión de if(!LocateElem(LA, e)) es la misma que unión.

//求两顺序表的差
void DiffList(SqList *LA,SqList *LB,SqList *&LC) 
{
	
	int j=0;ElemType e;   
	for (int i=1;i<=ListLength(LB);i++) 
	{	
		GetElem(LB,i,e);
		/*取LB中第i个数据元素赋给e*/
		if  (!LocateElem(LA,e)) 
			ListInsert(LC,++j,e); 	
                 /*LA中存在和e不相同者,则插入到LC中*/
	}
} 

función principal

Para los conjuntos AB y BA, solo es necesario intercambiar las posiciones de L1 y L2 en los parámetros formales de la función diferencia.

void main()
{
	SqList *L1;InitList(L1);
	ElemType a[4]={'A','B','C','D'};
	CreateList(L1,a,4);
	cout<<"线性表A的元素为:";DispList(L1);
	cout<<endl;

	SqList *L2;InitList(L2);
	ElemType b[5]={'B','C','E','F','G'};
	CreateList(L2,b,5);
	cout<<"线性表B的元素为:";DispList(L2);
	cout<<endl;

	///求并集
	SqList *L3;InitList(L3);
	unionList(L1,L2,L3);
	cout<<"A∪B:";
	DispList(L3);
	cout<<endl;

	///求交集
	SqList *L4;InitList(L4);
	InterList(L1,L2,L4);
	cout<<"A∩B:";
	DispList(L4);
	cout<<endl;

	///求差集
	InitList(L4);
	DiffList(L2,L1,L4);
	cout<<"A-B:";
	DispList(L4);
	cout<<endl;
	
	///求差集
	InitList(L4);
	DiffList(L1,L2,L4);
	cout<<"B-A:";
	DispList(L4);
	cout<<endl;
}