Tabla de contenido
2. Eliminar elementos duplicados en la lista enlazada ordenada.
1. Invertir la lista enlazada
https://leetcode.cn/problems/reverse-linked-list/?envType=study-plan&id=shu-ju-jie-gou-ru-men
1. Iteración
Supongamos que la lista enlazada es 1→2→3→∅ y queremos cambiarla a ∅←1←2←3.
Al atravesar la lista vinculada, cambie el siguiente puntero del nodo actual para que apunte al nodo anterior. Dado que un nodo no tiene referencia a su nodo anterior, su nodo anterior debe almacenarse de antemano. Este último nodo también debe almacenarse antes de cambiar la referencia. Finalmente, se devuelve la nueva referencia del encabezado.
class Solution {
public:
ListNode* reverseList(ListNode* head) {
ListNode* prev = nullptr;
ListNode* curr = head;
while (curr) {
ListNode* next = curr->next;
curr->next = prev;
prev = curr;
curr = next;
}
return prev;
}
};
Análisis de complejidad
-
Complejidad del tiempo: O (n), donde nn es la longitud de la lista vinculada. La lista vinculada debe recorrerse una vez.
-
Complejidad espacial: O(1).
2. recursividad
La versión recursiva es un poco más complicada y la clave es trabajar a la inversa. Supongamos que el resto de la lista enlazada se ha invertido, ahora ¿cómo
revertir la parte anterior?
Supongamos que la lista enlazada es:
n1-→...→+nk-1→nk→nk+1→...→nm→0
Si el nodo nk+1 a nm se ha invertido y estamos en nk
n1→...→nk-1→Nh:→nk+1←...←nm
queremos que apunte el siguiente nodo de nk+1 nk Entonces, np.next.next= nk.
Cabe señalar que el siguiente nodo de n1 debe apuntar a 0. Si esto se ignora, pueden ocurrir ciclos en la lista vinculada.
class Solution {
public:
ListNode* reverseList(ListNode* head) {
if (!head || !head->next) {
return head;
}
ListNode* newHead = reverseList(head->next);
head->next->next = head;
head->next = nullptr;
return newHead;
}
};
Análisis de complejidad
Complejidad del tiempo: O (n), donde n es la longitud de la lista vinculada. Cada nodo de la lista vinculada debe invertirse.
Complejidad espacial: O (n), donde n es la longitud de la lista vinculada. La complejidad del espacio depende principalmente del espacio de pila de las llamadas recursivas, que puede tener hasta n niveles.
2. Eliminar elementos duplicados en la lista enlazada ordenada.
1. Un recorrido
Ideas y algoritmos
Dado que la lista vinculada dada está ordenada, las posiciones donde aparecen elementos duplicados en la lista vinculada son consecutivas, por lo que solo necesitamos recorrer la lista vinculada una vez para eliminar los elementos duplicados.
Específicamente, apuntamos desde el puntero cur al nodo principal de la lista vinculada y luego comenzamos a recorrer la lista vinculada. Si los elementos correspondientes a cur y cur.next actuales son los mismos, entonces eliminaremos cur.next de la lista vinculada; de lo contrario, significa que no hay otros nodos con los mismos elementos correspondientes a cur en la lista vinculada. entonces cur puede apuntar a cur.next .
Después de recorrer toda la lista vinculada, volvemos al nodo principal de la lista vinculada.
detalle
Cuando atravesamos el último nodo de la lista vinculada, cur.next es un nodo vacío. Si no se juzga, acceder al elemento correspondiente de cur.next producirá un error de ejecución. Por lo tanto, solo necesitamos atravesar hasta el último nodo de la lista vinculada, en lugar de atravesar toda la lista vinculada.
código
Tenga en cuenta que el siguiente código C++ no libera el espacio del nodo de la lista vinculada eliminado. Si encuentra esta pregunta en una entrevista, los lectores deben comunicarse con el entrevistador sobre este detalle.
class Solution {
public:
ListNode* deleteDuplicates(ListNode* head) {
if (!head) {
return head;
}
ListNode* cur = head;
while (cur->next) {
if (cur->val == cur->next->val) {
cur->next = cur->next->next;
}
else {
cur = cur->next;
}
}
return head;
}
};
Análisis de complejidad
-
Complejidad del tiempo: O (n), donde nn es la longitud de la lista vinculada.
-
Complejidad espacial: O(1).