【LeetCode】61. Rotate List

题目：

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

Example 1:

Input: 1->2->3->4->5->NULL, k = 2
Output: 4->5->1->2->3->NULL
Explanation:
rotate 1 steps to the right: 5->1->2->3->4->NULL
rotate 2 steps to the right: 4->5->1->2->3->NULL

Example 2:

Input: 0->1->2->NULL, k = 4
Output: 2->0->1->NULL
Explanation:
rotate 1 steps to the right: 2->0->1->NULL
rotate 2 steps to the right: 1->2->0->NULL
rotate 3 steps to the right: 0->1->2->NULL
rotate 4 steps to the right: 2->0->1->NULL

 

描述：

给出一个链表，输出将该链表的右旋k个单位后的结果

 

分析：

线性表的右旋，是个比较有意思的题目，这里考察的是链表，

对于本题来说，首先k如果是链表长度的倍数，那么选择是无意义的，因此需要求出链表长度len，k对len取余，

然后只要能找到倒数第k个元素和最后一个元素，再进行链表的重新拼接即可，

需要注意的是链表为空的情况，需要特别处理，

 

代码：（时间复杂度O（n），空间复杂度 O（1））

/**
 * 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) {
		int len = 0;
		ListNode* last = getLastItem(head, len);
		
		if (!len || !(k%len) ) {
			return head;
		}
		k %= len;
		
		ListNode* my_head = new ListNode(0);
		ListNode* new_head = findRightItem(head, k);
		
		my_head->next = new_head->next;
		last->next = head;
		new_head->next = nullptr;
		
		return my_head->next;
	}
	
	ListNode* getLastItem(ListNode* head, int &len) {
		ListNode* my_head = new ListNode(0);
		my_head->next = head;
		while (my_head->next) {
			++ len;
			my_head = my_head->next;
		}
		return my_head;
	}
	
	ListNode* findRightItem(ListNode* head, int k) {
		ListNode* current = head;
		ListNode* result = head;
		while (k >= 0) {
			current = current->next;
			-- k;
		}
		while (current) {
			current = current->next;
			result = result->next;
		}
		return result;
	}
};