LeetCode Rotate List

class Solution {
public:
    ListNode *rotateRight(ListNode *head, int k) {
        if (head == NULL) return NULL;
        ListNode *p = head, *q = head;

        int dst = k;
        while (dst--) {
            q = q->next;
            if (q == NULL) {
                q = head;
                k = k % (k - dst);
                dst = k;
            }
        }
        if (p == q) return head;
        while (q->next != NULL) {
            q = q->next;
            p = p->next;
        }
        ListNode *new_head = p->next;
        p->next = NULL;
        q->next = head;
        return new_head;
    }
};

中间进行适当的判断防止k>>list.length，而list.length又很大的情况下，重复遍历链表时间的浪费，这样在k>=list.length的情况下都只需完整遍历一次链表即可

第二轮：

Given a list, rotate the list to the right by k places, where k is non-negative.

For example:
Given 1->2->3->4->5->NULL and k = 2,
return 4->5->1->2->3->NULL.

感觉脑子进水了，链表可以直接移动啊，艹！

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
 // 10:00
class Solution {
public:
    ListNode *rotateRight(ListNode *head, int k) {
        if (head == NULL) return NULL;
        
        int cnt = 0;
        ListNode* cur = head;
        while (cur) {
            cnt++;
            cur = cur->next;
        }
        k = k % cnt;
        
        if (k == 0) return head;
        
        ListNode* rhead = reverse(head, cnt);
        
        int sk = k;
        cur = rhead;
        while (sk--) {
            cur = cur->next;
        }
        
        ListNode* rhead_part1 = reverse(rhead, k);
        ListNode* rhead_part2 = reverse(cur, cnt - k);
        
        if (rhead_part1 != NULL) {
            rhead->next = rhead_part2;
        }
        
        return rhead_part1 == NULL ? rhead_part2 : rhead_part1;
    }
    
    ListNode* reverse(ListNode* head, int k) {
        ListNode* pre = NULL;
        ListNode* cur = head;
        while (k && cur) {
            ListNode* next = cur->next;
            cur->next = pre;
            pre = cur;
            cur = next;
            k--;
        }
        return pre;
    }
};

 赶紧再写一发：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *rotateRight(ListNode *head, int k) {
        if (head == NULL) {
            return NULL;
        }
        int cnt = 0;
        ListNode* pre = NULL;
        ListNode* cur = head;
        while (cur) {
            cnt++;
            pre = cur;
            cur = cur->next;
        }
        k = k % cnt;
        if (k == 0) {
            return head;
        }
        
        ListNode* last = pre;
        pre = NULL;
        cur = head;
        int rk = cnt - k;
        while (rk--) {
            pre = cur;
            cur = cur->next;
        }
        last->next= head;
        pre->next = NULL;
        return cur;
    }
};