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

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

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

题目链接 ：https://leetcode.cn/problems/swap-nodes-in-pairs/description/

题目

给你一个链表，两两交换其中相邻的节点，并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题（即，只能进行节点交换）。
示例 1：

输入：head = [1,2,3,4]
输出：[2,1,4,3]

示例 2：
输入：head = []
输出：[]

示例 3：
输入：head = [1]
输出：[1]

解题思路

这道题要使用虚拟头节点，这样方便后面的删除操作。然后交换的顺序，也是很讲究的，先用pre节点指向当前起始节点cur的下一个节点q，然后起始节点指向下一个起始节点t，即cur.next = cur.next.next;然后cur的下一个节点q指向起始节点cur，这时候两个节点已经交换了，然后前缀节点指向cur节点，因为前面已经交换完，即cur的未知是原来cur的下一个节点的未知，然后起始节点变为下一个起始节点t。可能有点绕，要画个图才好理解。具体代码为：

class Solution {
    public ListNode swapPairs(ListNode head) {
        if(head == null || head.next == null) return head; //链表为空或者链表只有一个元素
        ListNode dumty = new ListNode(0,head); //构建虚拟头节点
        ListNode pre = dumty; // 前缀节点
        ListNode cur = head; //当前起始节点，我这里是从head开始，有些代码是从虚拟头节点开始。但是操作的步骤基本是一样的
        while(cur != null && cur.next != null) { //不要漏掉cur.next，因为要记录cur.next/cur.next.next，所以它也不能为空
            ListNode q = cur.next; //用q指针记录当前指针的下一个节点，要交换的就是当前指针的节点和q指向的这个节点
            ListNode t = q.next; // 下一个要交换的起始节点
            pre.next = q; //先用前缀指针指向q，记录后面的链表（其实还有一个原因是因为后面要返回的是虚拟头节点的下一个节点，而交换后虚拟头节点的下一个头节点就是第一次开始交换的当前指针的下一个节点，也就是说这个指针就是交换后的链表的头节点，所以虚拟指针必须得指向它。）
            cur.next = q.next; //当前指针指向下一个起始指针
            q.next = cur; //q指针指向当前指针，完成两个节点的交换
            pre = cur; //下一个起始节点的前缀指针
            cur = t; //下一个起始节点，这个是我们一开始就记录的节点
        }
        return dumty.next;
    }
}

可以试试如果这几个步骤不按顺序会怎样，可能会出现链表断开的情况。

这道题还可以用递归的方法做，其实就是以反转链表为基础，这里我先给出代码，后续补充说明和相关题目。

import java.util.List;

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode swapPairs(ListNode head) {
        if (head == null) return head;
        ListNode a,b;
        a = b = head;
        for (int i = 0;i < 2; i++) {
            if (b == null) return head;
            b = b.next;
        }
        ListNode newHead = reverse(a,b);
        a.next = swapPairs(b);
        return newHead;
    public ListNode reverse(ListNode a,ListNode b) {
        ListNode t = null;
        ListNode p = a;
        while (p != b) {
            ListNode q = p.next;
            p.next = t;
            t = p;
            p = q;
        }
        return t;
    }
}

知识点

双指针，虚拟头节点，递归

注意事项

如何交换两个节点的步骤顺序，以及怎么记录使得交换遍历过程链表不会断。怎么去对链表的部分节点进行递归翻转

相关题目

25. K 个一组翻转链表

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

题目链接 ：https://leetcode.cn/problems/remove-nth-node-from-end-of-list/description/

题目

给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。
示例 1：

输入：head = [1,2,3,4,5], n = 2
输出：[1,2,3,5]

示例 2：
输入：head = [1], n = 1
输出：[]

示例 3：
输入：head = [1,2], n = 1
输出：[1]

解题思路

这道题我第一次接触的时候其实是没啥思路的，后面画图才环绕大悟。其实也就是双指针的应用。先用fast指针走n步，然后让fast指针和slow指针同时开始出发，直到fast指针遍历完链表，其实删除slow指针指向的节点就可以了。这里我给出虚拟头节点和不利用虚拟头节点的代码，不管用哪种，slow指针最后指向的是要删除节点的前一个指针，这样我们才能删除后面的节点。可以画个图理解一下，这也就是代码中fast指针先走n步还是n+1步。要注意的就是临界的判断条件，具体可以看代码：

class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {
       //不带虚拟头节点
        ListNode p = head;  
        ListNode q = head;
        for(int i = 0; i < n; i++){ //走n步，指向的是要删除节点的前一个节点
            p = p.next;  
        }
        if(p == null) {  //此时链表可能只有两个元素，而要删除的是倒数第二个即第一个节点
            return head.next;
        }
        while(p.next != null) {  //两个指针同时出发，当p指针==null，即遍历完链表，此时q指针指向要删除节点的前一个系欸但
            p = p.next;
            q = q.next;
        }
        q.next = q.next.next; //删除节点
        return head;

		//带虚拟头节点
        ListNode dumty = new ListNode(0,head);
        ListNode fast = dumty;
        ListNode slow = dumty;
        for(int i = 0;i <= n;i++) { //因为从虚拟头节点出发，所以fast指针要走n+1步，才到达要删除节点的前一个节点，下面的与上面的差不多
            fast = fast.next;
        }
        while(fast != null) {
            fast = fast.next;
            slow = slow.next;
        }
        if(slow.next != null) { //这里要判断当slow.next是否为空才行，因为可能链表就只有一个元素
            slow.next = slow.next.next;
        }
        return dumty.next;
    }
}

知识点

快慢指针，临界条件的判断

注意事项

快指针要走n步还是n+1步，临界条件的判断

相关题目

leecode 面试题 02.07. 链表相交

题目链接 ：https://leetcode.cn/problems/intersection-of-two-linked-lists-lcci/description/

题目

给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表没有交点，返回 null 。

图示两个链表在节点 c1 开始相交：

题目数据 保证 整个链式结构中不存在环。
注意，函数返回结果后，链表必须 保持其原始结构 。
示例 1：

输入：intersectVal = 8, listA = [4,1,8,4,5], listB = [5,0,1,8,4,5], skipA = 2, skipB = 3
输出：Intersected at ‘8’
解释：相交节点的值为 8 （注意，如果两个链表相交则不能为 0）。
从各自的表头开始算起，链表 A 为 [4,1,8,4,5]，链表 B 为 [5,0,1,8,4,5]。
在 A 中，相交节点前有 2 个节点；在 B 中，相交节点前有 3 个节点。
示例 2：

输入：intersectVal = 2, listA = [0,9,1,2,4], listB = [3,2,4], skipA = 3, skipB = 1
输出：Intersected at ‘2’
解释：相交节点的值为 2 （注意，如果两个链表相交则不能为 0）。
从各自的表头开始算起，链表 A 为 [0,9,1,2,4]，链表 B 为 [3,2,4]。
在 A 中，相交节点前有 3 个节点；在 B 中，相交节点前有 1 个节点。

解题思路

这道题可以用两个链表的差值，然后移动指针使两个链表从同一起始位置开始移动，具体代码为

public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        int counta = 0; 
        int countb = 0; 
        ListNode pa = headA;
        ListNode pb = headB;
        while(pa != null) { //记录A链表的长度
            pa = pa.next;
            counta++;
        }
        while(pb != null) {  //记录B链表的长度
            pb = pb.next;
            countb++;
        }
        pa = headA;//重新指向头节点
        pb = headB;
        int diff = counta - countb; //两个链表的差值
        if(diff > 0) { //移动链表，使得两个链表从同一位置开始出发
            for(int i = 0;i < diff;i++) {
                pa = pa.next;
            }
        }else if(diff < 0) {
            for(int i = 0; i < -diff;i++) {
                pb = pb.next;
            }
        }

        while(pa != null && pa != null) { //从同一位置开始出发，遇到相交的直接返回
            if(pa == pb) return pa;
            pa = pa.next;
            pb = pb.next;
        }
        return null; //没有相交的节点，返回null
    }
}

还有一种解法是，将两个链表拼接在一起，然后当遍历完两个链表的各自部分和公共部分后，就是相交的部分了，可以画个图理解。具体代码为

public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        ListNode pa = headA;
        ListNode pb = headB;
        while(pa != pb) {
            if(pa == null) { //此时遍历到A链表的末尾，从B链表开始，可以理解为将B链表拼接到A链表的末尾
                pa = headB;
            }else{
                pa = pa.next;
            }
            if(pb == null) { //此时遍历到B链表的末尾，从A链表开始，可以理解为将A链表拼接到B链表的末尾
                pb = headA;
            }else{
                pb = pb.next;
            }
            
        }
        return pa;
    }
}

知识点

双指针，链表的遍历

注意事项

进入循环的条件

相关题目

leecode 142. 环形链表 II

题目链接 ：https://leetcode.cn/problems/linked-list-cycle-ii/description/

题目

给定一个链表的头节点 head ，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。

如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。如果 pos 是 -1，则在该链表中没有环。注意：pos 不作为参数进行传递，仅仅是为了标识链表的实际情况。
不允许修改 链表。

示例 1：

输入：head = [3,2,0,-4], pos = 1
输出：返回索引为 1 的链表节点
解释：链表中有一个环，其尾部连接到第二个节点。

示例 2：

输入：head = [1,2], pos = 0
输出：返回索引为 0 的链表节点
解释：链表中有一个环，其尾部连接到第一个节点。

示例 3：

输入：head = [1], pos = -1
输出：返回 null
解释：链表中没有环。

解题思路

这道题依然是快慢指针的应用，跟链表有环是同样的思路，只不过这次是找环的起点，这里我是画图然后找到规律，就是先让快慢指针先走（快指针每次走两步，慢指针每次走一步，然后走到相等的位置，慢指针重新指向头节点，此时快指针和慢指针同时出发，各走一步，当两个指针走到同一位置时，即为环的起点。具体代码为：

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) break; // 快慢指针相遇，跳出循环
        }
        if (fast == null || fast.next == null) return null; //处理链表中不存在环的情况，如果链表中不存在环,那么 fast 指针最终会变成 null。
        slow = head; //慢指针重新指向头节点
        while(fast != slow) { //快慢指针再次相遇，即为环的入口
            fast = fast.next;
            slow = slow.next;
        }
        return slow;
    }
}

相关数学证明可以看代码随想录的解释，我感觉解释的很好。https://programmercarl.com/0142.%E7%8E%AF%E5%BD%A2%E9%93%BE%E8%A1%A8II.html#%E6%80%9D%E8%B7%AF

知识点

快慢指针，环形链表

注意事项

快慢指针第一次相遇到要怎么操作，临界条件的判断，进入循环的条件

相关题目

141 环形链表
287 寻找重复数