solve problem Rotate List

Author: P-ppc

README.md

@@ -184,6 +184,7 @@ All solutions will be accepted!
 |836|[Rectangle Overlap](https://leetcode-cn.com/problems/rectangle-overlap/description/)|[java/py/js](./algorithms/RectangleOverlap)|Easy|
 |643|[Maximum Average Subarray I](https://leetcode-cn.com/problems/maximum-average-subarray-i/description/)|[java/py/js](./algorithms/MaximumAverageSubarrayI)|Easy|
 |189|[Rotate Array](https://leetcode-cn.com/problems/rotate-array/description/)|[java/py/js](./algorithms/RotateArray)|Easy|
+|61|[Rotate List](https://leetcode-cn.com/problems/rotate-list/description/)|[java/py/js](./algorithms/RotateList)|Medium|
 |687|[Longest Univalue Path](https://leetcode-cn.com/problems/longest-univalue-path/description/)|[java/py/js](./algorithms/LongestUnivaluePath)|Easy|
 |28|[Implement Strstr](https://leetcode-cn.com/problems/implement-strstr/description/)|[java/py/js](./algorithms/ImplementStrstr)|Easy|
 |459|[Repeated Substring Pattern](https://leetcode-cn.com/problems/repeated-substring-pattern/description/)|[java/py/js](./algorithms/RepeatedSubstringPattern)|Easy|

algorithms/RotateList/README.md

@@ -0,0 +1,2 @@
+# Rotate List
+This problem is easy to solve

algorithms/RotateList/Solution.java

@@ -0,0 +1,35 @@
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode(int x) { val = x; }
+ * }
+ */
+class Solution {
+    public ListNode rotateRight(ListNode head, int k) {
+        int length = 0;
+        ListNode p = head,
+                 tail = head;
+        
+        while (p != null) {
+            tail = p;
+            p = p.next;
+            length++;
+        }
+        
+        if (length == 0 || k % length == 0)
+            return head;
+        
+        k %= length;
+        tail.next = head;
+        p = head;
+        
+        for (int i = 0; i++ < length - k - 1;)
+            p = p.next;
+        
+        ListNode temp = p.next;
+        p.next = null;
+        return temp;
+    }
+}

algorithms/RotateList/solution.js

@@ -0,0 +1,37 @@
+/**
+ * Definition for singly-linked list.
+ * function ListNode(val) {
+ *     this.val = val;
+ *     this.next = null;
+ * }
+ */
+/**
+ * @param {ListNode} head
+ * @param {number} k
+ * @return {ListNode}
+ */
+var rotateRight = function(head, k) {
+    let length = 0,
+        p = head,
+        tail = head
+    
+    while (p) {
+        tail = p
+        p = p.next
+        length++
+    }
+    
+    if (length == 0 || k % length == 0)
+        return head
+    
+    k %= length
+    tail.next = head
+    p = head
+    
+    for (let i = 0; i++ < length - k - 1;)
+        p = p.next
+    
+    let temp = p.next
+    p.next = null
+    return temp
+};

algorithms/RotateList/solution.py

@@ -0,0 +1,34 @@
+# Definition for singly-linked list.
+# class ListNode(object):
+#     def __init__(self, x):
+#         self.val = x
+#         self.next = None
+
+class Solution(object):
+    def rotateRight(self, head, k):
+        """
+        :type head: ListNode
+        :type k: int
+        :rtype: ListNode
+        """
+        length = 0
+        p = head
+        tail = p
+        while p:
+            tail = p
+            p = p.next
+            length += 1
+        
+        if length == 0 or k % length == 0:
+            return head
+        k %= length
+        tail.next = head
+        
+        p = head
+        for i in xrange(length - k -1):
+            p = p.next
+        
+        temp = p.next
+        p.next = None
+        
+        return temp