Given a linked list, rotate the list to the right by k places, where k is non-negative.
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
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
Restate the problem. Come up with (additional) test cases. Identify input/output data types, potential edge cases that may result in an error. Are there any time/space constraints?
The solution will take two inputs: a linked list and a non-negative integer, k. The output will be the linked list rotated to the right k places.
It could be possible that k = 0, in which case we could just return the linked list.
What if k is greater than the length of the linked list? We can rotate by k % length of the list.
What type of problem is this? What data structure could you use? Are there general techniques you’re familiar with that could apply?
This is a linked list problem. Since we are manipulating the nodes in the linked list, it would be beneficial to have a dummy head to maintain a pointer to the head as the node it references changes.
Since we are rotating the list by k places, we can use two pointers–one to point to the end of the list, and another to point to k % the length of the list away from the end pointer. That way we can make the node of this second pointer the new head and the end can point to the old head.
if head is null or head.next is null, return head if k is 0, return head # in case k is larger than the length # need helper function for length k <- k % length of linked list # check again if k is 0 (if len and k are same) if k == 0, return head # dummy head dummy <- ListNode(0, head) end <- head ptr <- head # move end k spaces away from ptr for i in range k end <- end.next # move both pointers until the end is reached while end.next isn't null end <- end.next ptr <- ptr.next dummy.next <- ptr.next # new head ptr.next <- end.next # new tail end.next <- head # append rest of list return dummy.next
Use your pseudocode to implement the idea in your chosen programming language
Test your code with various input to ensure you get the intended output
I actually did this in combination with the planning phase to ensure my plan was on the right track. However, after implementing, I did notice I needed to check if k == 0 again once I changed it to k % length of the list. In this case, I had to return the head. Otherwise, I’d get the incorrect output (empty list).
What is the time/space complexity of your solution? Discuss how it could be improved if possible and if time permits.
Space Complexity: O(n)
Time Complexity: O(n)