Programas para adultos
La operación es exitosa, pero al ingresar las listas La y Lb, tenga cuidado de no restar la entrada, de lo contrario ocurrirá un error. El autor puede modificar ListInsert para optimizarlo aún más, de modo que se almacene automáticamente en la lista independientemente de si se ingresa o no. Debido a que su función se insertó originalmente en una posición específica y no incluía ordenación por inserción, no la modifiqué. Si lo desea, puede cambiarlo directamente a lo siguiente:
int Linsert(lista enlazada ampl, ElemType e)
{
Enlace de temperatura, h, p , q;
int I = 0;
temp =(Enlace)malloc(tamañode(nodo));
temp->;
temp->; siguiente = NULL
h = GetHead(L);
if (h- gt; siguiente==NULL)
{
h- gt; siguiente = temp
L.tail = temp
l .len = 1;
}
Otro
{
p = h- gt; siguiente
q = h
y(p amp ampp->data lte)
{
q = p;
p = p- gt siguiente;
if(p==NULL)
{
L.tail->siguiente = temp
L .tail = temp
l .len;
}
Otro
{
temp->; ;
q->; siguiente = temp
l ;
}
}
Regresar. OK;
} Utilice esto para reemplazar directamente la función original, o no reemplazarla. Estas dos funciones sobrecargadas se seleccionan automáticamente en función de diferentes parámetros de entrada.
#Include " stdafx.h "
# include ltstdio.h gt
# include ltstdlib.h gt
#Elementos de definición Escriba int
#define NULL 0
typedef enum estado {normal, error}.
//
nodo de estructura typedef
{
Datos de tipo de elemento;
Nodo de estructura* siguiente
} *Enlace, *posición;
estructura typedef
{
Enlace cabeza y cola;
int len
}Lista de enlaces;
Cabeza de adquisición de enlaces (lista enlazada h)
{
Enlace q;
q = h .
Return (q);
}
Lista de inicialización de estado (lista enlazada ampl)
{
Enlace q;
q = l . tail = l . head =(Enlace)malloc(sizeof(node));
q->;
l . len = 0;
Regresar OK;
}
int ListInsert(lista enlazada ampl, int i, ElemType e)
{
Enlace s, p;
int j;
p = GetHead(L); p>Y (p amp ampj lti-1)
{ p = p- gt
j
}
s =(Enlace)malloc(tamañode(nodo));
s- gt;data = e;
p>
s- gt; siguiente = p- gt;
p->; siguiente = s
l . s; //// /////////////////
Volver OK;
}
Pantalla vacía (lista de enlaces L)
{
Enlace q, m;
q = GetHead(L);
m = q- gt; siguiente;
p>
Y (m!=null)
{
printf("d ",m- gt; datos) ;
m = m - gt; siguiente
}
printf("\n");
}
Enlace siguiente ubicación (enlace Lista L, enlace p)
{
Enlace q;
if(p == L.tail)
q = NULL
Otro
q = (p->; siguiente
Retorno (q);
}
ElemType GetCurElem(enlace p)
{
tipo de elemento q;
q = p->;datos ;
Retorno (q);
}
Estado DelFirst (enlace h, enlace amp pregunta)
{ //// //////// //////////////
Enlace p;
p = h- gt;
q = p;
h- gt; siguiente = p- gt;
Regresar
}
Anexo no válido (lista vinculada apl, enlace s)
{
L.tail->next = s;
l
.tail = s; ///////////////////
}
Estado de lista fusionada (lista vinculada y los, lista vinculada suma. Lista enlazada.
Lc)
{
Enlace ha, hb, pa, pb, q
Elemento tipo a, b
int comp; (tipo de elemento a, tipo de elemento b);
ha = GetHead(La);
HB = GetHead(Lb
pa = NextPos(La); , ja);
pb = NextPos(Lb, HB);
Y (pa amp amppb)
{
a = GetCurElem(pa);
b = GetCurElem(Pb);
if(comp(a, b)>=0)
{
DelFirst(ja, q);
Append(Lc, q);
pa = NextPos(La, ja);
}
Otros
{
DelFirst(hb, q
Append(Lc, q
pb); = NextPos(Lb, HB);
}
}
if(pa) Lc.tail->siguiente = pa/////// ////////
else LC . tail- gt; next = pb/////////////
Libre (hectárea);
Gratis (HB);
Devolver OK;
}
int comp(elemento tipo a, elemento tipo b)
{
int m;
si (a gtb)m = a;
si no m = b;
Retorno(m);
}
void main()
{
int n, I;
Lista enlazada La, Lb, Lc; ////////////////
Tipo de elemento temperatura;
InitList(La);
Printf("Ingrese el número de datos en la tabla: \ n ");
scanf("d ", ampn
Printf(" Por favor ingrese los datos de la tabla: \ n ");
for(I = 1; i lt= n; i )
{
scanf(" d " , amptemp);
ListInsert(La, I, temp);
}
InitList(Lb);
Printf (" Ingrese el número de datos en la tabla lb:\n ");
scanf("d", ampn);
Printf("Ingrese los datos en la tabla lb lb tabla:\n ");
for(I = 1; i lt= n; i)
{
scanf("d ", amptemp );
ListInsert(Lb, I, temp);
}
InitList(Lc
MergeList(La, Lb); , Lc);/ /////////////////
Pantalla (Lc); //////////////// /
}