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

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

题目链接：LeetCode
文章讲解：代码随想录
视频讲解：哔哩哔哩
编写语言：Java
完成状态：已完成

解题思路

• 定义虚拟头结点，通过三步骤，交换两个结点，再进行遍历 需要定义临时变量存储结点的值 画个图表示一下，将过程理解出来即可

代码

1. 画图

/**
 * 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 {
    /**
     * 将相邻的两个节点进行交换。
     * @param head 给定链表的头节点。
     * @return 交换后的链表的头节点。
     */
    public ListNode swapPairs(ListNode head) {
        // 创建一个虚拟的头节点，并将其指向原链表的头节点
        ListNode dummy = new ListNode(0, head);
        // 当前节点，初始值为虚拟的头节点
        ListNode cur = dummy;

        // 遍历链表，当当前节点和下一个节点都不为空时进行交换
        while (cur.next != null && cur.next.next != null) {
            // 记录要交换的两个节点的相关节点
            ListNode temp1 = cur.next;
            ListNode temp2 = cur.next.next.next;

            // 进行节点交换
            cur.next = cur.next.next;
            cur.next.next = temp1;
            cur.next.next.next = temp2;

            // 更新当前节点
            cur = cur.next.next;
        }

        return dummy.next; // 返回交换后的链表的头节点
    }
}

---

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

题目链接：LeetCode
文章讲解：代码随想录
视频讲解：哔哩哔哩
编写语言：Java
完成状态：已完成

解题思路

• 定义两个指针，fast先遍历到指向被操作结点（n+1）次，之后同时遍历 fast为null时，slow恰好之前被操作结点的前一个，之后按移除结点操作即可

代码

1. 快慢指针

/**
 * 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 {
    
    /**
     * 删除从链表末尾数第n个节点
     * @param head 链表头节点
     * @param n 要删除的节点位置
     * @return 删除节点后的链表头节点
     */
    public ListNode removeNthFromEnd(ListNode head, int n) {
        // 创建虚拟头节点，方便处理边界情况
        ListNode dummy = new ListNode(0, head);
        
        // 使用快慢指针来定位要删除的节点的前一个节点
        ListNode fast = dummy; // 快指针
        ListNode slow = dummy; // 慢指针
        
        // 快指针先移动n+1步
        while (n + 1 != 0) {
            fast = fast.next;
            n--;
        }
        
        // 快慢指针同时移动，直到快指针移到链表末尾
        while (fast != null) {
            fast = fast.next;
            slow = slow.next;
        }
        
        // 删除目标节点
        slow.next = slow.next.next;
        
        // 返回删除节点后的链表头节点
        return dummy.next;
    }
}

---

面试题 02.07. 链表相交

题目链接：LeetCode
文章讲解：代码随想录
编写语言：Java
完成状态：已完成

解题思路

• 将长链表指针移动到与短链表指针头结点的一个位置，即末尾位置对齐 在依次遍历找出相同位置时的指针头

代码

1. 双指针

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    // 双指针法找到两个链表的交点
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        // 获取链表A和链表B的长度
        int lenA = getLength(headA);
        int lenB = getLength(headB);
        // 计算链表A和链表B长度差
        int gap = Math.abs(lenA - lenB);

        // 定义两个指针，分别指向链表A和链表B的头结点
        ListNode curA = headA;
        ListNode curB = headB;

        // 如果链表A比链表B长，则curA先移动gap次，使得剩余部分长度相等
        if (lenA > lenB) {
            return getNode(curA, curB, gap);
        } else { // 如果链表B比链表A长，则curB先移动gap次，使得剩余部分长度相等
            return getNode(curB, curA, gap);
        }
    }

    // 求链表长度
    public int getLength(ListNode head) {
        ListNode cur = head;
        int len = 0;
        while (cur != null) {
            cur = cur.next;
            len++;
        }
        return len;
    }

    // 比较节点，默认A链表长
    public ListNode getNode(ListNode curA, ListNode curB, int gap) {
        // 如果其中一个链表为空，则没有交点
        if (curA == null || curB == null) {
            return null;
        } 

        // curA先移动gap次，使得剩余部分长度相等
        while (gap != 0) {
            curA = curA.next;
            gap--;
        }

        // 同时遍历两个链表，找到第一个相交的节点
        while (curA != null && curB != null) {
            if (curA == curB) {
                return curA;
            }
            curA = curA.next;
            curB = curB.next;
        }

        return null; // 如果没有交点，则返回null
    }
}

---

142.环形链表II

题目链接：LeetCode
文章讲解：代码随想录
视频讲解：哔哩哔哩
编写语言：Java
完成状态：已完成

解题思路

• 通过操作快慢指针判断环，再设置标志位进行等式运算 2(x+y)=x+y+n(y+z) x=n(y+z)-y x=(n-1)(y+z)+z n=1时，x=z

代码

1. 快慢指针

/**
 * Definition for singly-linked list.
 * class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = 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) { // 如果相遇则存在环
                ListNode index1 = fast; // 用index1指向相遇点
                ListNode index2 = head; // 用index2指向头节点
                while (index1 != index2) { // 当index1和index2不相同时
                    index1 = index1.next; // index1和index2同时向后移动一步
                    index2 = index2.next;
                }
                return index1; // 返回环的起始节点
            }
        }
        return null; // 若无环，则返回null
    }
}