Primero, ¿qué significa destruir la lista enlazada original? En teoría, esto no cambia las características de la lista enlazada original, solo pierde algunos nodos.
En segundo lugar, al eliminar el nodo duplicado L, el siguiente nodo de su predecesor no apunta al siguiente nodo del nodo eliminado, por lo que romperá la lista enlazada. No se puede formar una lista vinculada. Entonces no está bien hacer esto.
En tercer lugar,. ¿Por qué debería agregarse void del mismo nodo (lista de enlaces *;l) delante de l? , no es necesario agregar esta pregunta "".
El siguiente es el código depurado:
# include ltwindows.h gt
# include ltstring.h gt
# include ltmalloc .h gt
# include ltstdio.h gt
Lista enlazada de estructura
{
int x;
Estructura de lista enlazada * next
};
int flag = 0; //Definir una bandera y declararla como una variable global. En cuanto a si existe el mismo número
Lista vinculada de estructura *q, *h; //q sirve como puntero móvil y h sirve como puntero principal devuelto.
int in(int x, struct linklist *l)
{
Estructura lista enlazada *p, *t;
p = l;
Y (p!= NULL amp ampp->;x!=x)
{
p = p- gt;Siguiente;
}
si (p==NULL)
{
devuelve 0;
}
Otro
{
Devolver 1;
}
}
Lista vinculada de estructura* del (Lista enlazada estructural*l)
{
Lista enlazada estructural* p;
if(l = = NULL | | l- gt; next= =NULL)
{
return h;
}
si (en (l- gt; x, l- gt; next) )
{
p = l;
If (flag) //Si hay un número delante y no hay ningún número con el mismo número en la parte posterior,
Luego, el puntero del número anterior del número que se va a eliminar apunta al siguiente número.
{
q->; siguiente = p-gt;
l = l-gt;
De lo contrario //Si dicho número no existe, mueva L hacia abajo.
{
l = l-gt; siguiente;
}
Gratis
del(l);
}
Otro
{
Bandera;
Si (bandera= = 1) // Una vez que no existe un número después de él, H apunta a este número.
//y h sirven como puntero principal, solo una vez.
{
h = l;
}
q = l; //q todavía apunta a L para el siguiente movimiento del puntero .
del(l- gt; siguiente
}
}
int main()
); {
Lista enlazada de estructura *l, *p, *t;
int I;
t = p = l =(struct linklist *)malloc( sizeof(struct linklist));
for(I = 0;ilt6;i)
{
Si (i==0)
{
scanf("d ", amp(t->;x));
}
Otros
{
t =(struct linklist *)malloc(sizeof(struct linklist));
scanf("d ", amp(t->;x));
p>
p->; siguiente = t;
p = t
}
}
l = del(l);
Y (l!=null)
{
printf(" d ", l- gt; x);
l = l- gt; siguiente
}
Sistema("pausa") ;
p>}
Realicé tres posibles pruebas de entrada y no hubo ningún problema:
La primera: 1 2 3 4 5 6, la la salida sigue siendo 1 2 3 4 5 6.
El segundo tipo: 3 0 3 1 0 3, la salida es 1 0 3.
El tercer tipo: 1 2 3 4 6 4, la salida es 1 2 3 6 4.
Si tienes alguna otra duda, ¡llámame!