一文学会链表快慢指针解题技巧

    public Node findMiddleNode(){
    Node tmp = head.next;
        int middleLength = length / 2;
        while (middleLength > 0) {
        tmp = tmp.next;
        middleLength--;
    }
        return tmp;
}

    public Node findMiddleNodeWithoutHead(){
    Node tmp = head.next;
        int length = 1;
    // 选遍历一遍拿到链表长度
        while (tmp.next !=     null) {
        tmp = tmp.next;
        length++;
    }

    // 再遍历一遍拿到链表中间结点
    tmp = head.next;
        int middleLength = length / 2;
        while (middleLength > 0) {
        tmp = tmp.next;
        middleLength--;
    }
        return tmp;
}

/**
 * 使用快慢指针查找找到中间结点
 * @return
 */
    public Node findMiddleNodeWithSlowFastPointer(){
    Node slow = head.next;
    Node fast = head.next;
        while (fast !=     null && fast.next !=     null) {
        // 快指针走两步
        fast = fast.next.next;
        // 慢指针走一步
        slow = slow.next;
    }
    // 此时的 slow 结点即为哨兵结点
        return slow;
}

    public Node findKthToTail(    int     throws{
    Node slow = head.next;
    Node fast = head.next;

    // 快指针先移到第k个结点
        int tmpK = k - 1;
        while (tmpK > 0 && fast !=     null) {
        fast = fast.next;
        tmpK--;
    }
    // 临界条件：k大于链表长度
        if (fast ==     null) {
            throw    new Exception("K结点不存在异常");
    }
    // slow 和 fast 同时往后移，直到 fast 走到尾结点
        while (fast.next !=     null) {
        slow = slow.next;
        fast = fast.next;
    }
        return slow;
}

    public     void reversedKthToTail(    int     throws{
    // 直接调已实现的 寻找倒序k个结点的方法，这里是 k+1
    Node KPreNode = findKthToTail(k+1);
    // 倒数第 K 个结点
    Node kNode = KPreNode.next;
    Node headNext = head.next;

    KPreNode.next =     null;
    head.next = kNode;

    // 寻找尾结点
    Node tmp = kNode;
        while (tmp.next !=     null) {
        tmp = tmp.next;
    }
    // 尾结点的后继结点设置为原 head 的后继结点
    tmp.next = headNext;
}

    public     static Node detectCommonNode(LinkedList list1, LinkedList list2){
        int length1 = 0;        // 链表 list1 的长度
        int length2 = 0;        // 链表 list2 的长度

    Node p1 = list1.head;
    Node p2 = list2.head;

        while (p1.next !=     null) {
        length1++;
        p1 = p1.next;
    }

        while (p2.next !=     null) {
        length2++;
        p2 = p2.next;
    }

    p1 = list1.head;
    p2 = list2.head;

    // p1 或 p2 前进 |length1-length2| 步
        if (length1 >= length2) {
            int diffLength = length1-length2;
            while (diffLength > 0) {
            p1 = p1.next;
            diffLength--;
        }
    }     else {
            int diffLength = length2-length1;
            while (diffLength > 0) {
            p2 = p2.next;
            diffLength--;
        }
    }
    // p1,p2分别往后遍历，边遍历边比较，如果相等，即为第一个相交结点
        while (p1 !=     null && p2.next !=     null) {
        p1 = p1.next;
        p2 = p2.next;
            if (p1.data == p2.data) {
            // p1，p2 都为相交结点，返回 p1 或 p2
                return p1;
        }
    }
    // 没有相交结点，返回空指针
        return    null;
}

    public Node detectCrossNode(){
    Node slow = head;
    Node fast = head;

        while (fast !=     null && fast.next !=     null) {
        fast = fast.next.next;
        slow = slow.next;
        
            if (fast ==     null) {
                return     null;
        }

            if (slow.data == fast.data) {
                return slow;
        }
    }
        return     null;
}

    public Node getRingEntryNode(){
        // 获取快慢指针相遇结点
        Node crossNode = detectCrossNode();

        // 如果没有相遇点，则没有环
            if (crossNode ==     null) {
                return    null;
        }

        // 分别定义两个指针，一个指向头结点，一个指向快慢指针相交结点
        Node tmp1 = head;
        Node tmp2 = crossNode;

        // 两者相遇点即为环的入口结点
            while (tmp1.data != tmp2.data) {
            tmp1 = tmp1.next;
            tmp2 = tmp2.next;
        }
            return tmp1;
    }