Este artículo presenta el problema de la lista enlazada en el conjunto de problemas de LeetCode.
Otras preguntas de LeetCode sobre listas enlazadas:
Conjunto de problemas de LeetCode: Lista enlazada (1)
Conjunto de problemas de LeetCode: Lista enlazada (2)
19. Eliminar el nodo N del final de la lista (eliminar el último nodo N de la lista vinculada)
Descripción del problema
idea y codigo
Hay dos soluciones para este problema.
Primero, primero puede atravesar la lista para determinar la longitud y luego hacer otro recorrido para eliminar el nodo N de la parte inferior.
el código se muestra a continuación:
# Definition for singly-linked list.
# class ListNode:
# def __init__(self, val=0, next=None):
# self.val = val
# self.next = next
class Solution:
def removeNthFromEnd(self, head: ListNode, n: int) -> ListNode:
dummy = ListNode(val=-1, next=head)
num_node = 0 # number of nodes
while head:
num_node += 1
head = head.next
res = dummy
head = dummy
while head.next:
if num_node == n:
head.next = head.next.next
break
else:
num_node -= 1
head = head.next
res = res.next
return res
resultado de ejecución:
En segundo lugar, el método de puntero rápido y lento, primero mueva el puntero rápido N pasos y luego mueva los punteros rápido y lento al mismo tiempo. Cuando el puntero rápido se mueve hasta el final, el puntero lento está en la parte inferior N + 1 nodo, y su siguiente punto apunta al nodo inferior N-1 (siguiente siguiente nodo) es suficiente.
el código se muestra a continuación:
# Definition for singly-linked list.
# class ListNode:
# def __init__(self, val=0, next=None):
# self.val = val
# self.next = next
class Solution:
def removeNthFromEnd(self, head: ListNode, n: int) -> ListNode:
fast, slow = head, head
# move fast n steps in advance
for i in range(n):
fast = fast.next
# special case: remove the 1st node
if not fast:
return head.next
# move fast and slow together
while fast.next:
fast = fast.next
slow = slow.next
slow.next = slow.next.next # remove the nth node from the end
return head
resultado de ejecución:
203. Eliminar elementos de la lista enlazada
Descripción del problema
idea y codigo
La idea de esta pregunta es simple, recorrer los nodos uno por uno y modificar el siguiente parámetro del nodo anterior para el nodo que se debe eliminar.
el código se muestra a continuación:
# Definition for singly-linked list.
# class ListNode:
# def __init__(self, val=0, next=None):
# self.val = val
# self.next = next
class Solution:
def removeElements(self, head: ListNode, val: int) -> ListNode:
dummy = ListNode(val=-1, next=head)
head = dummy
while head.next:
if head.next.val == val:
head.next = head.next.next
else:
head = head.next
res = dummy.next
return res
resultado de ejecución:
61. Rotar lista
Descripción del problema
idea y codigo
La idea de esta pregunta es observar el resultado de la rotación de la lista enlazada, se puede ver que la rotación es equivalente a cortar la lista enlazada en dos segmentos y luego volver a unirlos. La posición de corte se puede determinar por el número de rotaciones k, y luego modificar el siguiente parámetro del nodo correspondiente.
Tenga en cuenta dos casos especiales:
- Cuando la lista enlazada está vacía, vuelve directamente a la lista enlazada vacía original
- Calcule el resto del número de rotaciones k a la longitud de la lista enlazada, si el resultado es 0, regrese a la lista enlazada original
el código se muestra a continuación:
# Definition for singly-linked list.
# class ListNode:
# def __init__(self, val=0, next=None):
# self.val = val
# self.next = next
class Solution:
def rotateRight(self, head: Optional[ListNode], k: int) -> Optional[ListNode]:
if not head:
return head
dummy = ListNode(val=-1, next=head)
num_node = 0
head = dummy
while head.next:
num_node += 1
head = head.next
# in case: k > num_node
k %= num_node
if not k:
return dummy.next
head_ori = dummy.next # original head
head = dummy.next
for _ in range(num_node - k):
head = head.next
dummy.next = head # new head
for _ in range(k - 1):
head = head.next
head.next = head_ori # next node of tail -> original head
for _ in range(num_node - k):
head = head.next
head.next = None
return dummy.next
resultado de ejecución:
La solución oficial del problema da otra forma de pensar.Primero, la lista enlazada se forma en un anillo, y luego se encuentra la posición del nodo correspondiente de acuerdo con el número de rotaciones k para resolver el anillo.
el código se muestra a continuación:
# Definition for singly-linked list.
# class ListNode:
# def __init__(self, val=0, next=None):
# self.val = val
# self.next = next
class Solution:
def rotateRight(self, head: ListNode, k: int) -> ListNode:
if not head or not head.next:
return head
n = 1 # number of nodes
cur = head
while cur.next:
cur = cur.next
n += 1
k %= n # k < n
if not k:
return head
cur.next = head
for _ in range(n - k):
cur = cur.next
res = cur.next
cur.next = None # break the loop
return res
resultado de ejecución:
