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

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

看见这道题第一感觉便是直接根据题意进行节点交换，所以考虑到可能对 head头节点进行交换，需要创建 dummyhead虚拟头节点  方便接下来的操作。

根据题意很简单，无非就是两个一组反转节点。但需要注意的问题就是需要将反转后的节点与后面的节点保持连接，并且还需要让指针移动指向到下一组需要反转的节点！！！

 所以创建 temp、node1、node2临时指针用于遍历链表、反转节点

 进行反转节点操作

temp.next = node2;
node1.next = node2.next;
node2.next = node1;

图示：

而接下来便需要思考如何移动指针继续遍历后续链表节点

观察可以发现可以将temp当做（node1，node2）的前驱节点，反转链表节点是（node1，node2）的内部操作。

 

我们便可以写出完整代码:

class Solution {
    public ListNode swapPairs(ListNode head) {
       ListNode dummyhead = new ListNode(-1);
       dummyhead.next = head;
       ListNode temp = dummyhead;
       ListNode node1;
       ListNode node2;
       while(temp.next != null && temp.next.next != null){
           node1 = temp.next;        // 定义node1节点
           node2 = temp.next.next;   // 定义node2节点

           temp.next = node2;         // 步骤1
           node1.next = node2.next;   // 步骤2
           node2.next = node1;        // 步骤3
            
            // 将temp视为 node1，node2 前驱节点。
            // 将 temp 移向 当前的node1，便可以定义 新的一组需要交换的节点，达到移动指针效果
           temp = node1;            
       }
       return dummyhead.next;
    }
}

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

这道题利用快慢指针技巧，在链表中要删除倒数第 n 个节点，就需要找到倒数第 n + 1 个节点才能进行删除操作 ，让一个fast指针指向虚拟头节点，并使其走 n + 1 步，再使另一个slow指针开始移动，当fast指针遍历结束时，此时slow指针刚好指向需要删除节点的前一个节点。

代码如下：

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

面试题 02.07. 链表相交

该题最大的问题就是两条链表的长度不一，无法直接对应。

而解题关键也变为了选择通过某种方式遍历两条链表，使两个遍历指针可以同时到达相交的节点

而观察可发现，如果把两条链表未相交的部分视为同一条链表部分进行遍历则可以同时到达相交节点，所以定义两个临时指针pA，pB进行遍历，当其中一个指针遍历结束一条链表时，使其指向另一条链表继续遍历，最后则可以同时达到相交节点

代码如下：

public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        ListNode pA = headA;
        ListNode pB = headB;
        while (pA != pB) {
            pA = (pA == null) ? headB : pA.next;
            pB = (pB == null) ? headA : pB.next;
        }
        return pA;
    }
}

142.环形链表II 

这道题还是快慢指针的应用，加上了一点数学知识

代码随想录 (programmercarl.com)我只能说卡哥分析远比我自己分析透彻了

（卡哥是真的神！！！）

直接给代码：

public class Solution {
    public ListNode detectCycle(ListNode head) {
        if(head == null)
            return null;

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