旋转链表解题思路

声明，此题目来自leecode61

题目：

给你一个链表的头节点 head ，旋转链表，将链表每个节点向右移动 k 个位置。

示例1：输入：head = [1,2,3,4,5], k = 2 输出：[4,5,1,2,3]

 示例2：输入：head = [0,1,2], k = 4 输出：[2,0,1]

提示：

• 链表中节点的数目在范围 [0, 500] 内
• -100 <= Node.val <= 100
• 0 <= k <= 2 * 109

链表的结构定义如下

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */

 思路：

首先想到的是，每一次旋转，都是将最后一个节点的next指向当前头节点，并作为新的头节点，然后倒数第二个节点的next指向空。

那能不能先获取到倒数第二个节点？

    // 获得倒数第二名的节点
    public ListNode getSecondLastNode(ListNode head) {
        ListNode current = head;
        while (current.next.next != null) {
            current = current.next;
        }
        return current;
    }

然后获取到一次旋转的新的头节点

    // 获取到一次旋转的新的头节点
    public ListNode getNewHead(ListNode oldHeadNode) {
        ListNode secondLastNode = this.getSecondLastNode(oldHeadNode);
        ListNode newHeadNode = secondLastNode.next;
        secondLastNode.next = null;
        newHeadNode.next = oldHeadNode;
        return newHeadNode;
    }

然后我们把k作为循环次数，对getNewHead进行循环

public ListNode rotateRight(ListNode head, int k) {
        ListNode newHeadNode = head;
        for (int i=1; i <= k; i++) {
            newHeadNode = this.getNewHead(newHeadNode);
        }
        return newHeadNode;
}

但是这样会有一个问题

对于 输入[1,2,3]  k=2000000000

这个算法的效率就太低了，循环的次数过多

这个时候，我们观察到

对于 [1,2,3]    k%链表长度的结果，是 1，2，0，1，2，0

有规律的循环往复的，而且结果=0，链表是不用旋转的。

 所以我们先求出链表长度，然后再跟k取模，整个算法变成下面这样

    public ListNode rotateRight(ListNode head, int k) {

        int round = k % this.getLength(head);
        if (round == 0) return head;
        ListNode newHeadNode = head;
        for (int i=1; i <= round; i++) {
            newHeadNode = this.getNewHead(newHeadNode);
        }
        return newHeadNode;
    }

    // 求出链表长度
    public int getLength(ListNode head) {
        int length = 1;
        ListNode current = head;
        while (current.next != null) {
            current = current.next;
            length ++;
        }
        return length;
    }

到这里，算法其实是已经可以走通了，但是大家有没有观察到

整个算法循环次数过多，

求出链表长度有循环，获取倒数第二个节点有循环，k的遍历还是循环。

那有没有效率更高的算法呢？有，用环。

环

我们把旋转前最后一个节点，跟头节点相连，我们就得到一个环。

现在的问题，就变成了，在这个环里面找到k次旋转后的最后一个节点，然后将它的next设置为空。

而头节点，就是最后一个节点的next。

k=1的时候，最后一个节点是2，相当于3 next遍历2次；

k=2的时候，最后一个节点是1，相当于3 next遍历1次；

k=3的时候，最后一个节点是3，链表不用旋转。

总结规律就是，旋转k次，链表最后一个节点需要遍历链表长度length-(k%length)

完整代码如下

前面数据校验是针对 输入 [] k=1 和 输入 [1]  k=1 这种特殊用例做的。

public ListNode rotateRight(ListNode head, int k) {
        // 数据校验
        if (k==0) return head;
        if (head == null) return head;
        if (head.next == null) return head;
        
        int length = 1;
        ListNode tmp = head;
        // 求出链表长度和最后一个节点
        while (tmp.next != null) {
            tmp = tmp.next;
            length ++;
        }
        k = k % length;
        if (k == 0) return head;
        // 首尾相连，形成一个环，这里的tmp就是最后一个节点
        tmp.next = head;
        // 找出旋转后的最后一个节点
        for (int i=1; i <= length-k; i++) {
            tmp = tmp.next;
        }
        // 新的头节点就是找到的最后一个节点的下一个节点
        ListNode newHeadNode = tmp.next;
        // 将找到的最后一个节点的 next 设置为空
        tmp.next = null;
        return newHeadNode;
    }