力扣刷题｜160. 相交链表|19. 删除链表的倒数第 N 个结点

160. 相交链表

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

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

题目数据保证整个链式结构中不存在环。

注意，函数返回结果后，链表必须 保持其原始结构 。

自定义评测：

评测系统 的输入如下（你设计的程序 不适用 此输入）：

intersectVal - 相交的起始节点的值。如果不存在相交节点，这一值为 0

listA - 第一个链表

listB - 第二个链表

skipA - 在 listA 中（从头节点开始）跳到交叉节点的节点数

skipB - 在 listB 中（从头节点开始）跳到交叉节点的节点数

评测系统将根据这些输入创建链式数据结构，并将两个头节点 headA 和 headB 传递给你的程序。如果程序能够正确返回相交节点，那么你的解决方案将被 视作正确答案 。

示例 1：
输入：intersectVal = 8, listA = [4,1,8,4,5], listB = [5,6,1,8,4,5], skipA = 2, skipB = 3
输出：Intersected at '8'
解释：相交节点的值为 8 （注意，如果两个链表相交则不能为 0）。
从各自的表头开始算起，链表 A 为 [4,1,8,4,5]，链表 B 为 [5,6,1,8,4,5]。
在 A 中，相交节点前有 2 个节点；在 B 中，相交节点前有 3 个节点。
— 请注意相交节点的值不为 1，因为在链表 A 和链表 B 之中值为 1 的节点 (A 中第二个节点和 B 中第三个节点) 是不同的节点。换句话说，它们在内存中指向两个不同的位置，而链表 A 和链表 B 中值为 8 的节点 (A 中第三个节点，B 中第四个节点) 在内存中指向相同的位置。

思路：

直接让两个链接着,形成类似一条线那种，然后遍历看看能不能相遇

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
      ListNode *  pA=headA,*pB=headB;
        while(pA!=pB){
            if (pA==nullptr) pA=headB;
            else pA=pA->next;
            if(pB==nullptr) pB=headA;
            else pB=pB->next;
        }
     return pA;
    }
};

删除链表的倒数第 N 个结点

思路：当要从链表的末尾删除第 n 个节点时，我们可以使用快慢指针的方法来解决。快指针先向前移动 n+1 步，然后慢指针开始移动。当快指针达到链表的末尾时，慢指针将指向要删除节点的前一个节点。这样，我们就可以将慢指针的 next 指针跳过要删除的节点，从而完成删除操作。

具体来说，解法的步骤如下：

创建一个虚拟节点 dummy，它的 next 指针指向链表的头节点 head。这是为了处理边界情况，例如删除头节点时，需要用到虚拟节点。
初始化快指针 fast 和慢指针 slow，都指向虚拟节点 dummy。
快指针 fast 先向前移动 n+1 步。这样，快指针和慢指针之间的间隔为 n 个节点。
同时移动快指针 fast 和慢指针 slow，直到 fast 指针到达链表的末尾为止。这会使得慢指针 slow 指向要删除节点的前一个节点。
修改慢指针 slow 的 next 指针，将其跳过要删除的节点，指向要删除节点的下一个节点。
返回虚拟节点 dummy 的 next 指针，即为删除节点后的链表头节点。

在这个解法中，使用虚拟节点可以避免对头节点进行特殊处理。同时，注意在删除节点后，要释放被删除节点的内存，以防止内存泄漏。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
       
       ListNode * dummy=new ListNode(-1);
       dummy->next=head;
        ListNode *fast=dummy;
        for(int i=0;i<n+1;i++){
            fast=fast->next;
        }
        ListNode *slow=dummy;
        while(fast!=nullptr){
            fast=fast->next;
            slow=slow->next;
        }
        slow->next=slow->next->next;
        return dummy->next;
    }
};