Titre original de Likou : liste chaînée rotative
Collez d'abord le code :
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;
}
}Analyse d'idée : Le titre nous dit que déplacer chaque nœud de la liste chaînée k positions vers la droite, en fait, cela revient à mettre le dernier nœud de la liste chaînée au début et le répéter k fois. À partir de là, nous pouvons penser à : pointer le nœud de queue vers le nœud de tête et répéter k fois, n'est-ce pas ? En effet, cette méthode est réalisable pour la première fois, mais nous devons répéter la boucle, et dans les opérations suivantes, nous devons constamment trouver le nœud de queue et le nœud précédent du nœud de queue, de sorte que tout le code devient extrêmement compliqué. et compliqué. Alors, y a-t-il un moyen plus simple ?
D'après le titre, nous pouvons savoir que nous devons continuellement ajouter le nœud de queue comme nœud de tête, puis nous connectons la tête et la queue de cette liste chaînée pour former un anneau, puis la faire tourner k fois, sinon nous pouvons mettre la queue nœud avant le nœud principal. Est-ce le nœud principal ? Mais une chose à noter à ce stade est que le titre signifie que nous devons tourner dans le sens des aiguilles d'une montre, et après avoir pratiqué la liste liée dans un anneau, nous ne pouvons tourner que dans le sens inverse des aiguilles d'une montre, car dans la liste liée individuellement, elle ne peut pointer que vers le nœud suivant et ne peut pas pointer vers le nœud précédent.
Nous supposons que la longueur de la liste chaînée est n, puis après connexion dans un anneau, faire k pas dans le sens des aiguilles d'une montre équivaut à faire nk pas dans le sens inverse des aiguilles d'une montre. Sachant cela, il est facile de conclure que lorsque la liste chaînée se déplace de k positions, notre anneau a fait nk pas dans le sens inverse des aiguilles d'une montre. Ensuite, bouclez à nouveau, puis définissez le champ suivant du nœud précédent du nœud principal pour qu'il soit vide, et le problème peut être résolu !