Las cuencas de tus ojos ardiendo son uno de los pocos momentos torpes y preciosos de tu vida.
Directorio de artículos
1. Lista inversa enlazada individualmente
Problemas que necesitan atención en el código.
2. Eliminar el elemento de la lista vinculada.
Problemas que necesitan atención en el código.
Hola a todos, soy Ji Ning.
Este artículo comparte con usted algunas soluciones a las preguntas clásicas de la prueba de lápiz leetcode de lista enlazada individualmente.
Conocimientos preliminares: estructura de datos - lista enlazada única
1. Lista inversa enlazada individualmente
Dado el nodo principal de la lista enlazada individualmente head , invierta la lista enlazada y devuelva la lista enlazada invertida.
Ideas de temas y diagramas
Idea: cambie la dirección del campo del puntero de cada nodo de la lista enlazada individualmente uno por uno de adelante hacia atrás, lo que consiste en invertir la lista enlazada individualmente en su conjunto .
Defina tres variables de estructura n1, n2, n3, donde n1, n2 se usan para cambiar el apuntamiento del nodo y n3 se usa para almacenar la dirección del siguiente nodo del nodo actual, es decir, el siguiente del nodo actual.
Cambie el diagrama de puntería. Inicialmente, n1 apunta a nada, n2 apunta al primer nodo y n3 apunta al segundo nodo.
struct ListNode* reverseList(struct ListNode* head) {
struct ListNode* n1, * n2, * n3;
n1 = NULL;
n2 = head;
if(n2!=NULL)
n3 = n2->next;
while (n2!= NULL)
{
n2->next = n1;
n1 = n2;
n2 = n3;
if(n3!=NULL)
n3 = n3->next;
}
return n1;
}Problemas que necesitan atención en el código.
1. Cuando el nodo entrante está vacío, n3 = n2 -> siguiente no se puede configurar porque n2 no tiene siguiente nodo.
2. Primero cambie la dirección y luego mueva n1, n2, n3 hacia adelante. Debido a que el nodo inicial se convierte en el nodo final después de voltear, el siguiente del nodo final debe apuntar a NULL.
3. Cuando n1, n2 y n3 avanzan, es necesario juzgar si n3 es NULL. Debido a que el final del ciclo de juicio es cuando n2 se mueve a NULL, antes de eso, n3 alcanzará NULL primero y es hora de hacer un juicio. Si n3 ya es NUL, n3 ya no se puede avanzar, de lo contrario aparecerá Situación fuera de límites.
2. Eliminar el elemento de la lista vinculada.
Dado un nodo principal de la lista vinculada head y un número entero val , elimine todos Node.val == val los nodos satisfechos en la lista vinculada y devuelva un nuevo nodo principal
Ideas de temas y diagramas
Idea: Para eliminar un nodo, si desea conocer la información del nodo anterior y del siguiente, debe definir dos variables de puntero de estructura, una que apunte al nodo actual y la otra que apunte al nodo anterior.
Defina una variable de puntero prev, responsable de apuntar al nodo anterior, deje que apunte a NULL primero; defina una variable de puntero cur, responsable de apuntar al nodo actual, deje que apunte primero al nodo principal
En circunstancias normales (el nodo que se va a eliminar está en el medio o al final), solo es necesario dejar que cur apunte al siguiente nodo de cur cuando el valor de cur->val es igual a val, y luego liberar el Espacio original, solo es necesario asegurarse de que prev Siempre seguido de cur.
Cuando el primer nodo va a eliminar el nodo, debe mover el nodo principal . Cuando se encuentra el primer nodo que no es igual a val, asigne el valor de cur a prev, y luego prev puede comenzar a moverse por primera vez, y luego cur avanzará.
struct ListNode* removeElements(struct ListNode* head, int val){
struct ListNode*cur=head;
struct ListNode*prev=NULL;
while(cur!=NULL)
{
if(cur->val==val)
{
if(head->val==val)
{
head=cur->next;
free(cur);
cur=head;
}
else
{
prev->next=cur->next;
free(cur);
cur=prev->next;
}
}
else
{
prev=cur;
cur=cur->next;
}
}
return head;
}Problemas que necesitan atención en el código.
Cuando es necesario eliminar un nodo, asigne el siguiente nodo anterior al siguiente nodo del nodo que se eliminará y luego libere el espacio de este nodo para lograr el nodo anterior y el que se eliminará. .
Cuando no necesite eliminar un determinado nodo y recorrer la lista vinculada normalmente, asigne el valor de prev a cur cada vez y luego apunte cur al siguiente nodo (cur = cur -> next), para que prev y cur puedan Se puede lograr avanzar juntos, y prev siempre está en el nodo anterior de cur.
