No puedo entender completamente la solución del problema 19 en Leetcode.
Entonces, cuando creamos rápido y lento, ¿creamos un enlace de cabeza? Por lo que puedo juzgar si. Pero luego iteramos con rápido: ¿por qué no cambia de cabeza? Me refiero a que en cada paso reemplazamos rápido con rápido.¿siguiente? Entonces, de alguna manera, no afecta la cabeza y la lentitud.
Y luego reemplazamos slow.next con slow.next.next y tiene un efecto en la cabeza.
¿Podría describir cómo no reemplaza nada en la primera parte y reemplaza en la segunda?
var removeNthFromEnd = function(head, n) { let fast = head, slow = head for (let i = 0; i < n; i++) fast = fast.next // why it doesn't change head and slow? if (!fast) return head.next while (fast.next) fast = fast.next, slow = slow.next slow.next = slow.next.next // why it change head? return head };Asignar algo a una variable no mutará un objeto.
Asignar algo a una propiedad mutará el objeto cuya propiedad está configurando.
En su caso, fast es una variable, por lo que asignarle algo como, por ejemplo, rápido. siguiente, nunca fast.next un objeto. Simplemente cambia lo que fast está haciendo referencia.
Por otro lado, slow.next es una propiedad. Asignar algo a esa propiedad mutará el objeto que slow referencias.
Visualicemos qué hace fast = fast.next . Supongamos que fast es el segundo nodo en una lista de 3:
Antes:
head fast ↓ ↓ ┌───────────┐ ┌───────────┐ ┌───────────┐ │ data: B │ │ data: G │ │ data: D │ │ next: ──────> │ next: ──────> │ next: null│ └───────────┘ └───────────┘ └───────────┘Después:
head fast ↓ ↓ ┌───────────┐ ┌───────────┐ ┌───────────┐ │ data: B │ │ data: G │ │ data: D │ │ next: ──────> │ next: ──────> │ next: null│ └───────────┘ └───────────┘ └───────────┘ Ahora mira lo que slow.next = slow.next.next . Supongamos que slow hace referencia al primer nodo:
Antes:
slow head ↓ ┌───────────┐ ┌───────────┐ ┌───────────┐ │ data: B │ │ data: G │ │ data: D │ │ next: ──────> │ next: ──────> │ next: null│ └───────────┘ └───────────┘ └───────────┘Después:
slow head ↓ ┌───────────┐ ┌───────────┐ ┌───────────┐ │ data: B │ │ data: G │ │ data: D │ │ next: ─────┐ │ next: ──────> │ next: null│ └───────────┘│ └───────────┘┌> └───────────┘ └───────────────┘Cuando haces fast = fast.next , estás cambiando una variable de referencia. fast ahora apunta al siguiente elemento de la lista.
Cuando haces slow.next = slow.next.next estás cambiando una propiedad del objeto al que apunta slow .
De hecho, en este ejemplo, head nunca cambia y siempre apuntará al primer elemento de la lista.