旋转链表？面试官你确定要让手写这个吗？

/**
 * @PACKAGE_NAME: com.lyl.linklist
 * @ClassName: Node
 * @Description:  单链表的 节点类
 * @Date: 2020-06-07 15:51
 **/
public class Node<T> {

    // 节点的数据域
    public T data;
    // 节点的指针域
    public Node next;

    /**
     * 构造方法
     * @param data 数据域值
     */
    public Node(T data) {
        this.data = data;
    }


    /**
     * 创建 单链表 （尾插法）
     * @return  返回头结点
     */
    public static Node createLinkedList(){
        // 头节点
        Node<String> head;

        Node<String> n = new Node<String>("111");
        Node<String> n1 = new Node<String>("222");
        Node<String> n2 = new Node<String>("333");
        Node<String> n3 = new Node<String>("444");
        Node<String> n4 = new Node<String>("555");
        Node<String> n5 = new Node<String>("666");
        // 指定头节点
        head = n;
        n.next = n1;
        n1.next = n2;
        n2.next = n3;
        n3.next = n4;
        n4.next = n5;
        // 返回头结点
        return head;
    }


    /**
     * 遍历单链表并在控制台打印输出
     * @param head  单链表的 头结点
     */
    public static void traverse(Node head) {
        while (head != null) {
            System.out.print(head.data + " --> ");
            head = head.next;
        }
        System.out.print("null");
        System.out.println();
    }

}

/**
 * @PACKAGE_NAME: com.lyl.linklist
 * @ClassName: RotateLinkedListByDoublePointer
 * @Description:  通过双指针法 旋转链表
 * @Date: 2020-06-07 16:00
 **/
public class RotateLinkedListByDoublePointer {

    /**
     *  旋转单链表
     * @param head   单链表 头结点
     * @param placeNum  向右移动的位置数
     */
    public static Node rotate(Node head, int placeNum){
        if (head == null)
            return null;
        // 临时节点
        Node temp;
        // 将临时节点指向头结点
        temp = head;
        // 记录单链表的长度
        int length = 1;
        // 遍历单链表得到其长度
        while (temp.next != null){
            length++;
            temp = temp.next;
        }
        /**
         *  如果单链表的长度小于移动的位置数
         * (注意：移动位置数是单链表长度的整数倍时，其实相当于单链表没有移动，还是原来的样式)
         */
        if (length <= placeNum){
            // 获取余数，也就是最终要向右移动的位置数
            placeNum = placeNum % length;
        }
        // 如果余数为0，和上面所说的单链表其实没有变化的
        if (placeNum == 0){
            return head;
        }

        // 当前节点指针
        Node current;
        // 前节点指针
        Node previous;
        current = head;
        previous = head;

        // 记录当前指针是否移动了(要求移动的位置数)
        int i = 0;
        while (current.next != null){
            /**
             * 在当前指针移动了(要求的位置数)后，并且当前指针还未移动到单链表的尾节点的话，
             * 此时需要current、previous指针一起移动了
             */
            if (i == placeNum){
                current = current.next;
                previous = previous.next;
            }else {
                // 在当前指针还未移动(要求的位置数)前，只有当前指针移动，previous指针不动
                i++;
                current = current.next;
            }
        }

        /**
         * 当 current指针移动到了链表的尾部后，此时指针移动结束，将当前previous、current指针截取的
         * 这段节点拼接到头节点前，并将previous指针指向的节点与后继结点断开连接
         */
        Node newTemp = previous.next;
        previous.next = null;
        current.next = head;

        return newTemp;
    }

    // Test
    public static void main(String[] args) {
        // 创建单链表
        Node head = Node.createLinkedList();
        System.out.print("新创建的单链表： ");
        // 遍历新创建的单链表
        Node.traverse(head);
        // 旋转链表，向右移动 10 个位置数
        Node newHead = rotate(head, 10);
        System.out.print("反转后的单链表： ");
        // 遍历反转后的单链表
        Node.traverse(newHead);
    }

}