用于链表顺时针旋转的Javascript程序

给定一个单链表和一个整数K ，任务是将链表顺时针向右旋转K位。
例子：

Input: 1 -> 2 -> 3 -> 4 -> 5 -> NULL, K = 2 
Output: 4 -> 5 -> 1 -> 2 -> 3 -> NULL
Input: 7 -> 9 -> 11 -> 13 -> 3 -> 5 -> NULL, K = 12 
Output: 7 -> 9 -> 11 -> 13 -> 3 -> 5 -> NULL 
 

方法：旋转链表首先检查给定的 k 是否大于链表中的节点数。遍历链表并找到链表的长度，然后将其与 k 进行比较，如果小于则继续，否则通过对链表的长度取模，在链表大小的范围内推导它。
之后从列表的长度中减去 k 的值。现在，问题已更改为链表的左旋转，因此请按照以下步骤操作：

• 将第 k 个节点的下一个节点更改为 NULL。
• 将最后一个节点的下一个节点更改为上一个头节点。
• 将头部更改为第 (k+1) 个节点。

为此，需要指向第 k 个节点、第 (k+1) 个节点和最后一个节点的指针。
下面是上述方法的实现：

Javascript

 
// JavaScript implementation of the approach   
 
/* Link list node */
 class Node {
        constructor() {
            this.data = 0;
            this.next = null;
        }
    }
 
    /* A utility function to push a node */
    function push(head_ref , new_data) {
        /* allocate node */
      var new_node = new Node();
 
        /* put in the data */
        new_node.data = new_data;
 
        /* link the old list off the new node */
        new_node.next = (head_ref);
 
        /* move the head to point to the new node */
        (head_ref) = new_node;
        return head_ref;
    }
 
    /* A utility function to print linked list */
    function printList(node) {
        while (node != null) {
            document.write(node.data + " -> ");
            node = node.next;
        }
        document.write("null");
    }
 
    // Function that rotates the given linked list
    // clockwise by k and returns the updated
    // head pointer
    function rightRotate(head , k) {
 
        // If the linked list is empty
        if (head == null)
            return head;
 
        // len is used to store length
        // of the linked list
        // tmp will point to the last
        // node after this loop
        var tmp = head;
        var len = 1;
        while (tmp.next != null) {
            tmp = tmp.next;
            len++;
        }
 
        // If k is greater than the size
        // of the linked list
        if (k > len)
            k = k % len;
 
        // Subtract from length to convert
        // it into left rotation
        k = len - k;
 
        // If no rotation needed then
        // return the head node
        if (k == 0 || k == len)
            return head;
 
        // current will either point to
        // kth or null after this loop
        var current = head;
        var cnt = 1;
        while (cnt < k && current != null) {
            current = current.next;
            cnt++;
        }
 
        // If current is null then k is equal to the
        // count of nodes in the list
        // Don't change the list in this case
        if (current == null)
            return head;
 
        // current points to the kth node
        var kthnode = current;
 
        // Change next of last node to previous head
        tmp.next = head;
 
        // Change head to (k+1)th node
        head = kthnode.next;
 
        // Change next of kth node to null
        kthnode.next = null;
 
        // Return the updated head pointer
        return head;
    }
 
    // Driver code
     
 
        /*
         * The constructed linked list is: 1.2.3.4.5
         */
        var head = null;
        head = push(head, 5);
        head = push(head, 4);
        head = push(head, 3);
        head = push(head, 2);
        head = push(head, 1);
 
        var k = 2;
 
        // Rotate the linked list
        var updated_head = rightRotate(head, k);
 
        // Print the rotated linked list
        printList(updated_head);
 
// This code contributed by Rajput-Ji
 

输出：

4 -> 5 -> 1 -> 2 -> 3 -> NULL

时间复杂度： O(n)，其中 n 是链表中的节点数。

辅助空间： O(1)

详情请参考链表顺时针旋转的完整文章！