[LeetCode]61.旋转链表

最新推荐文章于 2025-11-24 00:01:11 发布

原创最新推荐文章于 2025-11-24 00:01:11 发布 · 200 阅读

0 ·

CC 4.0 BY-SA版权

算法专栏收录该内容

12 篇文章

订阅专栏

博客探讨了如何优化链表旋转算法，从最初的实现导致超时问题，到通过计算链表长度和取模减少循环次数实现AC，最后采用连接成环的方法在O(1)时间内完成旋转，显著提高了效率。

[OT]My Answer

/**
 * 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; }
 * }
 */
class Solution {
    public ListNode rotateRight(ListNode head, int k) {
        if(head == null || head.next == null){
            return head;
        }
        int store = 0;
        ListNode p;
        for(int i = 0; i < k; i++){
            p = head;
            store = p.val;
            while(p.next != null){
                int tmp = p.next.val;
                p.next.val = store;
                store = tmp;
                p = p.next;
            }
            head.val = store;
        }
        return head;

    }
}

第一次写出来，能够解出符合要求的结果，但是超时了，因为循环的次数等于右移次数，若是右移次数相当大，则耗时很高。后考虑到移动次数较高时移动是循环进行的，可以先得到链表的长度，后让右移次数对长度取余，修改后的结果如下：

/**
 * 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; }
 * }
 */
class Solution {
    public ListNode rotateRight(ListNode head, int k) {
        if(head == null || head.next == null){
            return head;
        }
        int store = 0;
        ListNode p = head;
        int num = 1;
        while(p.next != null){
            num++;
            p = p.next;
        }
        int times = k % num;
        for(int i = 0; i < times; i++){
            p = head;
            store = p.val;
            while(p.next != null){
                int tmp = p.next.val;
                p.next.val = store;
                store = tmp;
                p = p.next;
            }
            head.val = store;
        }
        return head;

    }
}

修改后 AC 了，然而时间复杂度只超过了 8 % 的人，说明效率很低。

题解

连接成环

class Solution {
    public ListNode rotateRight(ListNode head, int k) {
        if (k == 0 || head == null || head.next == null) {
            return head;
        }
        int n = 1;
        ListNode iter = head;
        while (iter.next != null) {
            iter = iter.next;
            n++;
        }
        int add = n - k % n;
        if (add == n) {
            return head;
        }
        iter.next = head;
        while (add-- > 0) {
            iter = iter.next;
        }
        ListNode ret = iter.next;
        iter.next = null;
        return ret;
    }
}