¿Cómo fusionar dos tablas lineales secuenciales usando programación C?
1. La idea inicial es: tirar A y B en C, y luego ordenar C. La gente siempre piensa al principio en el método más perezoso, que a menudo es el método menos eficiente. Mejora: al ordenar A y B, primero coloque A en C, luego saque los elementos B uno por uno y busque el elemento insertado. Si la lista lineal no es una lista vinculada, hacerlo implicará mover una gran cantidad de elementos, lo que generará una gran sobrecarga. Método de mejora: saque un elemento de A y B, compárelos, luego coloque el elemento más pequeño en C, luego saque otro elemento de la tabla donde se acaba de sacar el elemento, compárelos nuevamente y luego coloque Se colocan elementos más pequeños en C. Repita esta operación hasta que se tome un elemento en A y B, y luego coloque todos los elementos restantes en C.
2. Ejemplo: #include?lt;stdlib.hgt;
/*Valor mínimo de la longitud del espacio de almacenamiento de la tabla de secuencia*/
#define?LISTMINSIZE ?10
//*Definición del tipo de estructura de almacenamiento de tabla de secuencia*/
typedef ?struct
{
ListDT*base;/ * Dirección base del espacio de tabla de secuencia */
intlistsize /* Tamaño del espacio de tabla de secuencia*/
intlen;?/* Longitud de la lista de secuencia*/
} SeqList;
/* Inicialización de lista de secuencias*/
void?ListInitialize(SeqList?*pL,?int?size)
{
if(sizelt.LISTMINSIZE)
size=LISTMINSIZE;/* El límite no puede ser menor que el tamaño mínimo*
pL-gt;listize=size;
pL-gt; base=(ListDT*)malloc(pL-gt; tamaño de lista*) tamaño de(ListDT));
if(!pL-gt;base)
exit(EXIT_FAILURE);
pL-gt;len=0;/* Inicializar tabla vacía**
}
//// Obtener lo dado Valor del elemento de la lista de secuencia en el subíndice*/
BOOL?ListElem(SeqList?L, ?int?index, ?ListDT?*pelem)
{
BOOLflg =VERDADERO;
if(indexlt;0||?base[index];
returnflg;
}
/ /* La longitud de la tabla de secuencia de búsqueda**
int?ListLen( SeqList?L)
{
returnL.len;?
}
/* Insertar un elemento en la posición del número de secuencia especificado en la lista de secuencias*/
BOOL?ListInsert(SeqList?*pL,?int?pos,?ListDT? d)
{
BOOLflg=TRUE;
inti;
if(poslt;0||?pL-gt;lengt ;= pL-gt;listize?||?posgt;pL-gt;len)
flg=FALSE;
else
{
for(i=pL- gt;len-1;igt;=pos;?i--)?/* Datos móviles*** pL-gt;base[i 1]=pL-gt;base[i ];
pL-gt; base[pos]=d;?/* Escribir datos*/
pL-gt;?/* Aumentar la longitud de la tabla en 1* *
}
returnflg;
}
/* Elimina el elemento con el número de serie especificado en la tabla de secuencia***
BOOL?ListDel(SeqList?*pL,?int?pos)
{
BOOLflg=TRUE;
inti;
si(po
slt;0||?posgt;=pL-gt;len)
flg=FALSE;
else
{
para (i=pos 1;ilt;pL-gt;len;?i)/* Datos móviles** pL-gt;base[i-1]=pL-gt;base[i];
pL-gt; len--; /* La longitud de la tabla se incrementa en 1**
}
returnflg
}
int?ListLoc(SeqList?L,?ListDT?d,BOOL?(*equal)(ListDT,ListDT))
{
intpos=L.len-1;
mientras(posgt;= 0amp;amp;?(*equal)(L.base[pos],d))
pos--;
returnpos;
}
/* Obtener la posición del número de serie del elemento principal**
BOOL?ListPrior( SequList?L,?int?pos,?int?*ppriorpos)
{
BOOLflg=TRUE;
if(posgt; 0amp;amp;? poslt; L.len)
*ppriorpos=pos-1;
else
flg=FALSE;
returnflg;
else
flg=FALSE;
returnflg;
else
p>
}
/* Obtener la posición del número de elemento posterior*
BOOL?ListNext(SequList?L, ?int?pos, ?int?*pnextpos)
{
BOOLflg=TRUE;
if(posgt;=0amp;amp;?poslt;L.len-1)
* pnextpos= pos 1;
else
flg=FALSE;
returnflg;
}
/* Destruir secuencial Tabla*/
void?ListDestroy(SeqList?L)
{
gratis(L.base);
}
#endif
/*~~~~~~~~~~ ~~~~~~~~~~~~~~~~~~~~~~ ~~ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
/*
Programa de prueba recomendado
*/
typedef?enum?{TRUE=1, FALSE=0}?BOOL;
typedef?int?ListDT;
#include?"seqlist.c"
void?printSeqList(SeqList?L)
{
inti;
ListDTx ;
printf("\nList:\n");
for(i=0; ilt; ListLen(L);?i )
{
ListElem(L, i, y x;
printf("3d", x
);}
}
BOOL?dataequal(int?x, ?int?y)
{
return(x ==y)?VERDADERO: FALSO;
}
#define?
void?main ()
{
inti, prioridad, siguiente;
ListDTx, prueba[N]={10, 20, 30, 40, 50}
SeqListL
//* Inicializar lista de secuencia*
ListInitialize(amp; L, N);
//* Insertar N elementos al principio de la tabla*/
for(i=0;ilt;N;?i)
ListInsert(amp; L, 0, prueba[i]);
printSeqList(L);
/*Eliminar elemento**/
ListDel(amp; L, N/2
printSeqList(L
); printf( "\ninputa?key:\n");
scanf("d",amp;x);
//* Encuentra la posición de x en la tabla* /
i=ListLoc(L, x, dataequal);
/* Encuentra el elemento principal de x*/
if(ListPrior(L, i , amp; prioridad ))
{
ListElem(L, prioridad, amp; x);
printf("Anterior: d\n", x );
p>}
else
printf("noPrior.\n");
//*Encontrar el sucesor of x*
if(ListNext(L, i, amp; siguiente))
{
ListElem(L, siguiente, amp; x);
printf("Siguiente: d\n",x);
}
else
printf("noSiguiente .\n");
/*La longitud de la tabla de búsqueda*/
printf("Listlength=d", ListLen(L));
/*Destruir la tabla secuencial* /
ListDestroy(L);
}