旋转链表

给定一个链表，旋转链表，将链表每个节点向右移动 k 个位置，其中 k 是非负数。

• 示例 1:

	输入: 1->2->3->4->5->NULL, k = 2
	输出: 4->5->1->2->3->NULL
	解释:
	向右旋转 1 步: 5->1->2->3->4->NULL
	向右旋转 2 步: 4->5->1->2->3->NULL

• 示例 2:

	输入: 0->1->2->NULL, k = 4
	输出: 2->0->1->NULL
	解释:
	向右旋转 1 步: 2->0->1->NULL
	向右旋转 2 步: 1->2->0->NULL
	向右旋转 3 步: 0->1->2->NULL
	向右旋转 4 步: 2->0->1->NULL

/**
 * 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 || k == 0) {
            return head;
        }

        // 计算链表的长度
        ListNode *p = head;
        int listSize = 0;
        while(p) {
            listSize ++;
            p = p->next;
        }

        // 计算偏移量，考虑为负数情况
        int move;
        if (k > 0) {
            move = k % listSize;
        } else {
            move = (k % listSize + listSize) % listSize;
        }
        if (move == 0 || move == listSize) {
            return head;
        }

        // 双指针法找到要偏移的位置
        ListNode *p1 = head;
        ListNode *p2 = head;

        for (int i=0; i<move; i++) {
            p2 = p2->next;
        }

        while(p2->next) {
            p2 = p2->next;
            p1 = p1->next;
        }

        // 截取最后的链表
        p2 = p1->next;
        p1->next = NULL;

        p1 = p2;
        while(p1->next) {
            p1 = p1->next;
        }

        // 将截取的链表放在头部
        p1->next = head;
        head = p2;
        return head;
    }
};

先形成环，然后找到合适的位置断开

/**
 * 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 || k == 0) {
            return head;
        }
        ListNode *p = head;
        int listSize = 1;
        while(p->next) {
            listSize ++;
            p = p->next;
        }

        if (k < 0) {
            k = k % listSize + listSize;
        } else {
            k = k % listSize;
        }

        if (k == 0 || k == listSize) {
            return head;
        }

        // 形成环
        p->next = head;
        p = head;

        for (int i=1; i<listSize-k; i++) {
            p = p->next;
        }
        head = p->next;
        p->next = NULL;
        return head;
    }
};