leetcode

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.

这个题目主要是要理解清楚rotate的含义，这个含义和二进制数的右移有点类似，不过这里补高位的数是右移出去的数

个人思路：

1，先计算链表长度，记为listSize，可以发现若k等于listSize时，右移之后的链表与原链表是相同的，因此实际的移动量为k % listSize，若k % listSize等于0，就说明右移之后的链表等于原链表，直接返回原链表即可

2，若k % listSize在1到listSize - 1之间，则需要定位出两部分链表的边界，由于右半部分的链表长度是k % listSize，且总长度是listSize，所以左半部分的链表长度为listSize - k % listSize，从链表头部开始遍历，即可得到边界结点，然后重新连接这两个链表即可

代码：

#include <stddef.h>

struct ListNode
{
    int val;
    ListNode *next;
    ListNode(int x) : val(x), next(NULL) {}
};

class Solution {
public:
    ListNode *rotateRight(ListNode *head, int k) {
        if (!head)
        {
            return NULL;
        }

        ListNode *current = head;
        ListNode *tail = NULL; //链表尾结点
        int listSize = 0; //链表长度

        while (current) //计算链表长度
        {
            if (!current->next)
            {
                tail = current;
            }
            current = current->next;
            ++listSize;
        }

        k = k % listSize; //计算实际的移动量

        if (k == 0) //若k等于0，则返回原链表
        {
            return head;
        }

        current = head;

        for (int i = 1; i < (listSize - k); ++i) //定位到链表断开的位置
        {
            current = current->next;
        }

        ListNode *leftHead = head;
        ListNode *leftTail = current;
        ListNode *rightHead = current->next;
        ListNode *rightTail = tail;

        //旋转链表
        leftTail->next = NULL;
        rightTail->next = leftHead;
        head = rightHead;

        return head;
    }
};

网上基本上是这个思路