Encontré un problema en lenguaje C y espero que alguien pueda ayudarme a implementar este problema en lenguaje C: encontrar la intersección, unión y diferencia de dos conjuntos cualesquiera.
Anteriormente escribí una matriz en lenguaje C puro, que simula la implementación de set_intersection, set_union y set_difference en C STL. Lo modifiqué un poco y agregué algunos comentarios, espero que ayude. Nota: La colección de entrada debe ordenarse primero; los resultados de salida son consistentes con los resultados de la prueba C STL. #include lt;stdio.hgt;
#include lt;stdlib.hgt;
#include lt;string.hgt;
#include lt;string .hgt;
int set_intersection (const int Set1[], const unsigned int SizeofSet1, const int Set2[], const unsigned int SizeofSet2, int Res[], unsigned int* pSizeofRes);
int set_union (const int Set1[], const unsigned int SizeofSet1, const int Set2[], const unsigned int SizeofSet2, int Res[], unsigned int* pSizeofRes);?
int set_difference (const int Set1[], const unsigned int SizeofSet1, const int Set2[], const unsigned int SizeofSet2, int Res[],?
int compare (const void * a, const void * b);
void print_array(const int arr[], const size_t len
int main(int argc, char** argv)
p>
{
int primero[] = {5, 10, 15, 20, 25};
int segundo[] = {50, 40, 30, 20 , 10};
unsigned int size1, size2, size_intxn, size_union, size_diff, retcode
int *pr_intxn, *pr_union, *pr_diff; *Requisito previo: la colección debe estar ordenada.
*/
tamaño1 = tamaño de (primero) / tamaño2, tamaño de (int), comparar
/* Intersección */
tamaño_intxn = (tamaño1 gt); ; tamaño2) ?tamaño1 : tamaño2; /* Tamaño estimado del resultado*/
pr_intxn = (int *)malloc(sizeof(int) * size_intxn);
if (NULL == pr_intxn) {p>
If (NULL == pr_intxn) {p>
Este es el resultado. intxn) {
printf("Error de memoria de intersección.\n");
return -1;
}
printf( "1) Conjunto de intersección:\n");
retcode = set_intersection(primero, tamaño1, segundo, tamaño2, pr_intxn, amp; size_intxn);
if (retcode == 0)
print_array(pr_intxn, size_intxn);
else
printf("Error en set_intersection, código d\n", retcode
free(pr_intxn);
/* Union*/
size_union = size1 size2; /* Tamaño estimado del resultado*/
pr_union = ( int *)malloc(sizeof(int) * size_union); /* Resultado de preasignación*/
if (NULL == pr_intxn) {
If (NULL == pr_ union) ) {
printf("Error de memoria de unión.\n");
return -1;
}
printf(" 2 ) Conjunto de unión:\n");
retcode = set_union( primero, tamaño1, segundo, tamaño2, pr_union, amp; size_union);
if (retcode == 0 )
print_array(pr_union, size_union);
else
printf("Error en set_union, código d\n", retcode);
free(pr_union);
/* Diferencia*/
size_diff = size1 size2; /* Tamaño estimado del resultado*/
pr_diff = (int *)malloc(sizeof(int) * size_diff); /* Resultado de preasignación*/
if (NULL == pr_diff) {
printf("Error de memoria de diferencia.
\n");
return -1;
}
printf("3) Conjunto de diferencias:\n");
retcode = set_difference(primero, tamaño1, segundo, tamaño2, pr_diff, & size_diff);
if (retcode == 0)
print_array(pr_diff, size_diff);
else
printf("Error en set_difference, código d\n", retcode);
free(pr_diff);
return 0 ;
}
/* Entrada:
Conjunto1 - primer conjunto
Conjunto2 - segundo conjunto SizeofSet1: establece la longitud del primer conjunto.
SizeofSet2: establece la longitud del segundo conjunto. Entrada/Salida: ?
Res: el conjunto utilizado para almacenar los resultados.
pSizeofRes: puntero a SizeofRes, la longitud del resultado. Si SizeofRes es menor de lo esperado, se devolverá el tamaño apropiado a la persona que llama:
0: en caso de éxito. 1 - SizeofRes es más pequeño de lo esperado
-1 - Error de memoria interna.
*/
int set_difference (const int Set1[], const unsigned int SizeofSet1, const int Set2[], const unsigned int SizeofSet2, int Res[], unsigned int* pSizeofRes )
{
int i, j, k;
unsigned int size_pre;
int *pr = 0;
size_pre = SizeofSet1 SizeofSet2;
if ( *pSizeofRes lt; size_pre)
{
* pSizeofRes = size_pre;
return 1;
}
pr = (int *)malloc(size_pre * sizeof(int));
if ( pr == NULL )
return -1;
i = 0; j = 0;
mientras ( i lt; SizeofSet1 amp; j lt; SizeofSet2 )
{
if (Conjunto1[i] lt; Conjunto2[j]) pr[k] = Conjunto1[i]; si no (Conjunto2[j] lt; ; conjunto1[i]) j;
else
{ i ; j ;}
{i ; j ;}
memcpy (pr k, Conjunto1 i-1, tamañode(int)*(TamañodeConjunto1-i 1));
k = TamañodeConjunto1-i
memcpy (Res, pr, k*; sizeof(int));
*pSizeofRes = k;
free(pr);
Devuelve 0;
}?
int set_union (const int Set1[], const unsigned int SizeofSet1, const int Set2[], const unsigned int SizeofSet2, int Res[], unsigned int* pSizeofRes)
{
int i, j, k;
unsigned int size_pre;
int *pr = 0
size_pre = Tamaño del conjunto1 Tamaño del conjunto2; /p>
if ( *pSizeofRes lt; size_pre)
{
*pSizeofRes = size_pre;
devuelve 1;
}
pr = (int *)malloc(size_pre * sizeof(int));
if ( pr == NULL )
return -1;
i = 0; j = 0; k = 0;
mientras ( 1 )
<p>{
if (i gt; SizeofSet1 - 1)
{
memcpy( pr k, Set2 j-1, sizeof(int)*( TamañodeConjunto2-j 1));
k = TamañodeConjunto2 - j;
romper;
}
if (j gt; TamañodeConjunto2 - 1)
{
memcpy(pr k, Set1 i-1, sizeof(int)*(SizeofSet1-i 1));
k = Tamaño de Conjunto1 - i;
romper
}
if (Conjunto1[i] lt; Conjunto2[j]) pr[k] = Conjunto1[i] ;
de lo contrario si (Conjunto2[j] lt; Conjunto1[i]) pr[k] = Conjunto2[j];
de lo contrario { pr[k] = Conjunto1[i] ; i; j; }
k;
}
memcpy(Res, pr, k*sizeof(int)); >*pSizeofRes = k;
free(pr);
return 0;
}?
int set_intersection (const int Set1) [], const unsigned int SizeofSet1, const int Set2[], const unsigned int SizeofSet2, int Res[], unsigned int* pSizeofRes)
{
int i, j, k ;
unsigned int size_pre;
int *pr = 0;
size_pre = (SizeofSet1 gt.SizeofSet2) ?SizeofSet1: SizeofSet1: SizeofSet2;
if ( *pSizeofRes lt; size_pre)
{
*pSizeofRes = size_pre;
devuelve 1;
}
pr = (int * )malloc(size_pre * sizeof(int));
if ( pr == NULL )
return -1; p>
p>
i = 0; j = 0; k = 0
mientras ( i lt; SizeofSet1 amp; j lt; SizeofSet2 )
{
si (Conjunto1[i] lt; Conjunto2[j]) i
si no (Conjunto2[j] lt; Conjunto1[i])
de lo contrario
{
pr[k ] = Conjunto1[i ];
i ; /p>
}
memcpy(Res, pr, k*sizeof(int));
*pSizeofRes = k;
free(
pr);
return 0;
}
void print_array(const int arr[], const size_t len)
{
int i;
for (i = 0; i lt; len; i)
printf("d ", arr[i]
printf("\n");
}
int comparar (const void * a, const void * b)
{ retorno ( *(int*)a - *(int*)b );
}