Darle el nodo principal de una lista vinculada, rotar la lista vinculada y mover cada nodo de la lista vinculada k posiciones a la derecha.

Título original de Likou: Lista rotativa enlazada

Primero pega el código:

public class Solution61 {
    public ListNode rotateRight(ListNode head, int k) {
        //当链表为空或者链表只有一个元素或者移动0步的时候的情况
        if (head == null || head.next == null || k == 0){
            return head;
        }
        //创建一个虚拟头节点，指向head
        ListNode newhead = new ListNode(-1);
        newhead.next = head;
        //求出链表长度
        int len = 1;
        ListNode cur = head;
        while (cur.next != null){
            cur = cur.next;
            len++;
        }
        //进行头尾相连
        cur.next = head;
        //求出链表形成的环实际要走的步数a
        int a = len-k%len;
        //开始循环a步
        while (a != 0){
            newhead.next = newhead.next.next;
            a--;
        }
        //将新头节点的上一个节点的next域置为空，使其从环再次变为链表
        cur = newhead.next;
        while (cur.next != newhead.next){
            cur = cur.next;
        }
        cur.next = null;
        //返回newhead的下一个节点，即是新的头节点
        return newhead.next;
    }
}

Análisis de la idea : El título nos dice que mover cada nodo de la lista enlazada k posiciones a la derecha, de hecho, significa poner el último nodo de la lista enlazada al principio y repetirlo k veces. A partir de esto, podemos pensar en: apuntar el nodo de la cola al nodo de la cabeza y repetir k veces, ¿verdad? De hecho, este método es factible por primera vez, pero necesitamos repetir el bucle y, en las operaciones posteriores, debemos encontrar constantemente el nodo de cola y el nodo anterior del nodo de cola, por lo que todo el código se vuelve extremadamente complicado. y complicado desperdicio. Entonces, ¿hay una manera más fácil?

Por el título, podemos saber que necesitamos anteponer continuamente el nodo de cola como el nodo de cabeza, luego conectamos la cabeza y la cola de esta lista enlazada para formar un anillo, y luego lo rotamos k veces, de lo contrario podemos poner la cola nodo anterior al nodo principal. ¿Es el nodo principal? Pero una cosa a tener en cuenta en este momento es que el título significa que debemos rotar en el sentido de las agujas del reloj, y después de practicar la lista enlazada en un anillo, solo podemos rotar en el sentido contrario a las agujas del reloj, porque en la lista enlazada solo, solo puede apuntar a la siguiente nodo y no puede apuntar al nodo anterior. 

Suponemos que la longitud de la lista enlazada es n, luego, después de conectarse en un anillo, dar k pasos en el sentido de las agujas del reloj es equivalente a dar nk pasos en el sentido contrario a las agujas del reloj. Sabiendo esto, es fácil concluir que cuando la lista enlazada se mueve k posiciones, nuestro anillo ha dado nk pasos en sentido antihorario. Luego, haga un bucle nuevamente y luego configure el siguiente campo del nodo anterior del nodo principal para que esté vacío, ¡y el problema se puede resolver!