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

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

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

题目连接：24. 两两交换链表中的节点 - 力扣（LeetCode）

1. 注意这个题目说的是只能节点交换，不能交换值！一开始想的是用两个指针记录两节点，再交换其值。

2. 思路：cur 指向虚拟头节点，按照下图红色箭头的顺序，依次改变节点的指针指向，最后拉直链表就完成1号节点和2号节点进行交换的操作。将指针cur 向右移动两位可完成3和4节点的交换，以此类推。
   

3. 注意循环终止的条件，当cur的下一个节点为空或者下下个节点为空时表示已经移到链表尾部。注意判断cur.next 和 cur.next.next 的顺序，若 cur.next.next 在前会引起空指针报错。

4. 细节方面还需注意两个临时变量最好是在前面初始化，不要在交换节点的过程中需要临时节点在申请和初始化。比如在完成了步骤 1 后在初始化temp3变量 ，这时temp3记录的是4号节点而不是3号节点，因为在完成步骤1后cur.next.next.next指向的节点变成了4号节点。就是因为这个，整个思路自我感觉下来没错，但是输出结果不对，找了好久bug呜呜呜

class Solution {
    public ListNode swapPairs(ListNode head) {
        ListNode dummyhead = new ListNode();//虚拟头节点
        dummyhead.next = head;
        ListNode cur = dummyhead;
        ListNode temp1 = new ListNode();//记录两个交换节点中的第1个节点
        ListNode temp3 = new ListNode();//记录两个交换节点中第2个节点的下一个节点
        while(cur.next != null && cur.next.next != null){
            temp1 = cur.next;
            temp3 = cur.next.next.next;
            cur.next = cur.next.next;
            cur.next.next = temp1;
            temp1.next = temp3;
            cur = cur.next.next;//cur右移两位
        }
        return dummyhead.next;
    }
}

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

题目连接：19. 删除链表的倒数第 N 个结点 - 力扣（LeetCode）

1. 思路：用双指针思想（快慢指针），快指针和慢指针都指向虚拟头节点，快指针先右移 n 位，然后快指针和慢指针同时向右移动，当快指针指向链表末尾时，慢指针所指向的节点就是需要删除的节点。
2. 删除节点时我们需要找到该节点的前驱节点进行删除操作。
3. 注意循环条件的判断，因为这里我用了虚拟头节点，当判断条件是 fast.next != null 时，快指针要移动 n 步；当判断条件是 fast != null 时，快指针要移动 n+1 步。如果没用虚拟头节点可以自行参照思路判断。

class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {
        ListNode dummyhead = new ListNode(0,head);//虚拟头节点
        ListNode fast = dummyhead;//快指针
        ListNode slow = dummyhead;//慢指针
        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 dummyhead.next;
    }
}

三、面试题 02.07. 链表相交

题目连接：面试题 02.07. 链表相交 - 力扣（LeetCode）

1. 思路：这题也是用双指针思想，和19. 删除链表的倒数第 N 个结点 - 力扣（LeetCode） 中心思想大同小异。用两个临时指针分别指向两个链表的头节点，将两个链表以链表尾部为起点对齐，利用长度差使长链表的临时指针移动到，与短链表的临时指针对齐，然后遍历两个链表对齐的节点是否相等，相等则返回该节点。

public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        ListNode cur1 = headA;
        ListNode cur2 = headB;
        int size1 = 0, size2 = 0;
        while(cur1 != null){
            size1++;
            cur1 = cur1.next;
        }
        while(cur2 != null){
            size2++;
            cur2 = cur2.next;
        }
        cur1 = headA;
        cur2 = headB;
        //保证变量名为A链的长度比变量名为B链长度长，若不是则交换一下（形参）
        if(size1 < size2){
            int temp;  temp= size1; size1 = size2; size2 = temp;
            ListNode tempNode = new ListNode();
            tempNode = cur1; cur1 = cur2; cur2 = tempNode;
        }
        int n = size1 - size2;
        for(int i =0; i < n; i++){
            cur1 = cur1.next;
        }
        while(cur1 != null){
            if(cur1 == cur2){
                return cur1;
            }
            cur1 = cur1.next;
            cur2 = cur2.next;
        }
        return cur1;
    }
}

四、142.环形链表II

题目连接：142. 环形链表 II - 力扣（LeetCode）

1. 算法的终点是数学！！！这题也是用双指针的思想

2. 判断链表是否有环：快指针和慢指针都指向头节点，快指针每次移动2步，慢指针每次移动1步，如果快指针和慢指针在移动过程中相遇了，就表示该链表有环，反之无环。

3. 如何找到这个环的入口：这就涉及到数学知识了，设头节点——环形链表入口节点的距离为 x ，环形链表入口节点——相遇结点的距离为 y ，相遇结点的距离沿着链表再次到环形链表入口节点的距离为 z ，当相遇时：

   slow指针： x + y

   fast指针： x + n * (x + y) (n表示fast在环中转的圈数)

   fast指针移动速度是slow指针的2倍，相同时间内，移动距离也是2倍
   故有 ： 2* (x + y) = x + n * (x + y)

   化简后： x = (n - 1)*(y + z) + z

​ 这里由于fast指针的速度是slow指针的两倍，一定会在fast走到第2圈的时候追上slow指针。所以 n = 1;

​ 上述化简后的公式 变成：x = z；到此后可以再利用双指针分别从相遇节点和头节点循环遍历，直到两指针相

​ 遇，相遇处即是环形链表入口节点处。

4. 注意这里快指针虽然走2步，但以慢指针为参考物，快指针每次只走了1步，对于慢指针来说是快指针一步一步地走向自己，只要时间够长一定会相遇；但是如果快指针每次走3步或者其他步数，就有可能跳过慢指针从而错过。

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 index1 = fast;//记录相遇点
                ListNode index2 = head;
                while(index1 != index2){// x=z
                    index1 = index1.next;
                    index2 = index2.next;
                }
                return index1;
            }
        }
        return null;
    }
}