代码随想录算法训练营第四天| 24.两两交换链表中的节点，19.删除链表的倒数第N个节点，面试题 02.07. 链表相交，142.环形链表II

文档讲解：24.两两交换链表中的节点、19.删除链表的倒数第N个节点、面试题 02.07. 链表相交 、142.环形链表II

题目链接：24.两两交换链表中的节点、19.删除链表的倒数第N个节点、面试题 02.07. 链表相交、142.环形链表II

视频讲解：24.两两交换链表中的节点_哔哩哔哩_bilibili、19.删除链表的倒数第N个节点_哔哩哔哩_bilibili、142.环形链表II

思路：

1、第一道题需要三个指针，思路并不复杂，细心画图，将cur、firstNode、secondNode的关系捋清楚并不难。

2、第二道题也是一个经典的双指针问题，首先想到的是遍历一遍计数再计算删除第n个节点，但是看之前代码好像并没有这样做，再看讲解，是用的双指针，定义一个快指针先走n步，一个慢指针在虚拟头结点不动，之后快慢指针一起动，直到快指针的下一个节点为空，将慢指针的下一个节点指向下一个的下一个，就删除掉了倒数第n个节点。

3、第三题比较难想的点是两个链表相等的条件，并不是val相等两个链表就相等了，而是从当前节点到最后节点所有节点都相等才是相等，所有val都相等也不是相等。所以先遍历两个链表计算其长度，再将较长链表的节点移动到和较短链表相等长度的节点，然后每个节点进行比较，相等则输出当前节点，遍历到最后都不相等，则输出null。

4、第四题是今天最难的一道题，花费了一个小时才看解析理解并写出来，其中最难的一部分是判断进环点，通过计算得到进环点。判断有无环是经典快慢指针问题。

**24.**两两交换链表中的节

class Solution {
    public ListNode swapPairs(ListNode head) {
        ListNode dummy = new ListNode(-1);
        dummy.next = head;
        ListNode cur = dummy;
        ListNode firstNode;
        ListNode secondNode;
        while(cur.next!=null && cur.next.next!=null){
            ListNode temp = cur.next.next.next;
            firstNode = cur.next;
            secondNode = cur.next.next;

            secondNode.next = firstNode;
            firstNode.next = temp;
            cur.next = secondNode;

            cur = cur.next.next;
        }
        return dummy.next;
    }
}

19.删除链表的倒数第N个节点

class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {
        ListNode dummy = new ListNode(0,head);
        ListNode slow = dummy;
        ListNode fast = dummy;
        for(int i=0;i<n;i++){
            fast = fast.next;
        }
        while(fast.next!=null){
            fast = fast.next;
            slow = slow.next;
        }
        slow.next = slow.next.next;
        return dummy.next;
    }

}

面试题 02.07. 链表相交

public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        int lengthA=0,lengthB=0;
        ListNode tempA = headA;
        ListNode tempB = headB;
        while(tempA != null){
            lengthA++;
            tempA = tempA.next;
        }
        while(tempB != null){
            lengthB++;
            tempB = tempB.next;
        }

        ListNode curA = headA;
        ListNode curB = headB;
        if(lengthA>lengthB){
            for(int i=0;i<lengthA-lengthB;i++){
                curA = curA.next;
            }
        }else{
            for(int i=0;i<lengthB-lengthA;i++){
                curB = curB.next;
            }
        }
        while(curA!=null){
            if(curA == curB){
                return curA;
            }else{
                curA = curA.next;
                curB = curB.next;
            }
        }
        return null;
    }
}

142.环形链表II

public class Solution {
    public ListNode detectCycle(ListNode head) {
        ListNode fast = head;
        ListNode slow = head;
        while(fast!=null && fast.next!=null){
            fast = fast.next.next;
            slow = slow.next;
            if(fast == slow){
                ListNode pointA = fast;
                ListNode pointB = head;
                while(pointA != pointB){
                    pointA = pointA.next;
                    pointB = pointB.next;
                }
                return pointA;
            }
        }
        return null;
    }
}