algoritmo pitón diario (series lista) _leetcode 92. lista Reverse II

lista inversa desde la posición de m a n. Por favor use el viaje a la exploración es completa reversión.

Descripción:
. 1 lista ≤ ≤ m ≤ n de longitud.

Ejemplo:

Entrada: 1-> 2-> 3-> 4- > 5-> NULL, m = 2, n = 4
de salida: 1-> 4-> 3-> 2- > 5-> NULL

Fuente: Botón de estancia (LeetCode)
enlace: https: //leetcode-cn.com/problems/reverse-linked-list-ii

Método a: el primer método de interpolación

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution:
    def reverseBetween(self, head: ListNode, m: int, n: int) -> ListNode:
        if not head or not head.next or m==n: #不先处理这些情况会慢一些
            return head
        dummy = ListNode(0)
        dummy.next = head  # 头插法
        pre = dummy  #dummy留着不动，用来最后返回
        for _ in range(m-1):
            pre = pre.next   #到要处理的节点的前一个
        tail = pre.next  #第m个节点，处理完后是末尾的n位置节点
        cur = pre.next.next
        for _ in range(n-m):  #反转
            tmp = pre.next   
            tmp1 = cur.next
            pre.next = cur  #pre的位置是不动的，一直往pre后面插当前cur节点
            cur.next = tmp
            cur = tmp1
        tail.next = cur #反转完后cur指向最后不用反转的部分，把它连上去
        return dummy.next

Cf. ejemplo, a la parte posterior de este método es la posición m-1 ha sido interpolado nodo. Debido reversión parcial pre se ha unido a la parte, siempre que la sección final de la cola de conexión como

La totalidad de los cambios simulados:

0-> 1-> 3 <-> 2 4-> 5-> NULL

0-> 1-> 4-> 3 <-> 2 5-> NULL # 2.next aquí si no el puntero a la bucle sin fin 5 excederá el límite de tiempo

0-> 1-> 4-> 3-> 2-> 5-> NULL

Aquí el inicio del maniquí en el más con el fin de evitar el caso de m = 1 es menor que el procesamiento

Método dos: puntero inversa

class Solution:
    def reverseBetween(self, head: ListNode, m: int, n: int) -> ListNode:
        if not head or not head.next or m==n:
            return head
        dummy = ListNode(0)
        dummy.next = head
        prehead = dummy  #不用反转的前面部分
        for i in range(m-1):
            prehead = prehead.next
        cur = prehead.next #开始反转的位置
        tail = prehead.next
        pre = None #一个空的前向指针
        for i in range(n-m+1): #这里n-m+1，才能pre指向n,cur指向n+1
            tmp = cur.next
            cur.next = pre
            pre = cur
            cur = tmp
        prehead.next = pre  #前连中
        tail.next = cur   # 连上尾
        return dummy.next

Haciendo referencia a los ejemplos, el maniquí de inversión: 0-> 1-> 2, pre: 2 <-3 <-4, cur: 5-> NULL

Incluso hasta: roto 0-> 1-> 4-> 3-> 2 entre 1, 2 y luego conectado a 5, dummy: 0-> 1-> 4-> 3-> 2-> 5-> NULL

Aquí tapón ciego no está en la parte delantera no puede manejar el caso de m = 1

Escrito esto un poco más rápido, casi métodos

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution:
    def reverseBetween(self, head: ListNode, m: int, n: int) -> ListNode: 
        if m == n:
            return head
        dummy = ListNode(0)
        dummy.next = head
        a, d = dummy, dummy
        for _ in range(m - 1):
            a = a.next
        for _ in range(n):
            d = d.next
        b, c = a.next, d.next
        pre = b
        cur = pre.next
        while cur != c:
            next = cur.next
            cur.next = pre
            pre = cur
            cur = next
        a.next = d
        b.next = c
        return dummy.next

 También puede ser demasiado torpe: mantener el trato con otra lista Jieshangqu

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution:
    def reverseBetween(self, head: ListNode, m: int, n: int) -> ListNode:
        if not head or not head.next or m==n:
            return head
        res = []
        while(head):
            res.append(head.val)
            head = head.next
        lista = res[:m-1]
        listb = res[m-1:n][::-1]
        listc = res[n:]
        lista.extend(listb)
        lista.extend(listc)
        cur = ListNode(0)
        dummy = cur
        for i in lista:
            cur.next = ListNode(i)
            cur = cur.next
        return dummy.next