给你一个链表的头节点 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

试题解析

题意：将链表向右移动k次，移动后的元素头插到链表

如果我们采用次次头插的方式，十分浪费时间

于是我们可以根据k把链表分为两个部分，后面的链表的尾节点指向前面的链表的头结点

方法如下：

• 首先计算链表长度
• 找到链表分开的节点，使此节点的下一个指向空，并保存此节点的next节点，即后面链表的头结点
• 遍历至后面链表的尾节点，指向前面的链表的头结点

注意：当链表长度为num时，往右移动num位后，链表仍为之前的状态
           所以简化计算，k = k % num;

代码如下：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* rotateRight(ListNode* head, int k) {
        if(head == nullptr) return head;

        ListNode* pTemp = head;
        ListNode* cur = nullptr;
        int num = 0;
        // 计算链表个数
        while(pTemp != nullptr){
            num ++;
            pTemp = pTemp->next;
        }
        //取k的最小值
        k %= num;
        if(k == 0) return head;
        pTemp = head;
        int n = 0;
        while(pTemp != nullptr){    
            n++;        
            if(n + k == num)
            {
                //记录当前节点的下一个，即后面要移动的链表的头结点
                cur = pTemp->next;
                //使前面链表尾节点的下一个指向空
                pTemp->next = nullptr;
                break;
            }
            pTemp = pTemp->next;
        }
        pTemp = cur;
        //遍历至后面的链表的尾节点，使其指向前面链表的头结点
        while(cur && cur->next != nullptr){
            cur = cur->next;
        }
        cur->next = head;
        return pTemp;
    }
};