代码随想录【链表】---＞删除倒数第N个节点、链表相交、环形链表

⭐️代码随想录⭐️
数组篇:
二分查找
移除数组
有序数组的平方
长度最小的数组
螺旋矩阵
链表篇：
链表移除
设计链表
反转链表
交换链表中的节点

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

题目LeetCode19. 删除链表的倒数第 N 个结点

思路

这道题的逻辑比较清晰
1. 先找到倒数第n+1个节点
2. 删除倒数第n个节点
为什么要找倒数第n+1个节点而不是倒数第n个节点呢？因为删除第n个节点时我们需要知道该节点的前一个节点在哪里，修改前一个节点的指针域来实现删除该节点，所以关键在于如何寻找倒数第n+1个节点
可以通过快慢指针来寻找倒数第n+1个节点，让快指针始终在慢指针前面n+1个长度，这样当快指针走到链表结尾时，慢指针指向的就是倒数第n+1个节点
思考：本题是否需要和之前的提题目一样构造虚拟头节点呢？

使用虚拟头节点会更加方便，因为这题有可能会将头节点删除，这样不能够直接返回head，而使用虚拟头节点可以将真正的头节点和其他的节点统一处理，最后只需要返回dummHead->next即可

代码

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */


struct ListNode* removeNthFromEnd(struct ListNode* head, int n){
    typedef struct ListNode ListNode;
    //构造虚拟头节点
    ListNode* dummyHead = (ListNode*)malloc(sizeof(ListNode));
    dummyHead->next = head;
    ListNode* fast = dummyHead;
    ListNode* slow = dummyHead;
    //快指针先走n + 1步
    int cnt = 0;
    while (cnt < n + 1)
    {
        //判断删除的节点是否合法
        if (fast == NULL)   return head;
        fast = fast->next;
        cnt++;
    }
    //快慢指针同时移动，直到快指针遍历完
    while (fast)
    {
        slow = slow->next;
        fast = fast->next;
    }
    //slow是待删除节点的下一个节点
    //删除节点
    ListNode* tmp = slow->next;
    slow->next = tmp->next;
    free(tmp);
    //返回新的头节点
    return dummyHead->next;
}

---

面试题 02.07. 链表相交

题目LeetCode面试题 02.07. 链表相交

思路

首先明白一点：链表相交指的是两个链表从某一个节点开始往后所有的节点在物理空间上的地址是一样的，而不是节点的val域一样
如果两链表相交，那么相交的部分最多的情况就是从较短的链表头节点开始相交，所以先让长链表遍历到一个位置使该位置往后的节点数和短链表节点数相同,从该位置开始判断链表节点的空间是否一样,继续判断两链表后一个节点的位置是否一样
如果链表不相交,那么直到curA和curB遍历完后两个指针的值仍然不相交(物理空间不同)

代码

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
struct ListNode *getIntersectionNode(struct ListNode *headA, struct ListNode *headB) {
    typedef struct ListNode ListNode;
    int lenA = 0;
    int lenB = 0;
    ListNode* curA = headA;
    ListNode* curB = headB;
    //求A链表的节点数
    while (curA)
    {
        lenA++;
        curA = curA->next;
    }
    //求B链表节点数
    while (curB)
    {
        lenB++;
        curB = curB->next;
    }
    curA = headA;
    curB = headB;
    //求两链表长度差
    int gap = lenA - lenB;
    //对齐链表末尾
    if (gap > 0) while (gap--) curA = curA->next;
    else
    {
        gap *= -1;‘//注意gap为负数的情况
        while (gap--) curB = curB->next;
    }
    //寻找相同节点
    while (curA)
    {
        //找到相交的第一个节点了，后续的节点一定相交
        if (curA == curB)   return curA;
        //两链表的该节点不相交，继续向后遍历
        else 
        {
            curA = curA->next;
            curB = curB->next;
        }
    }
    return NULL;
   
    
}

---

142. 环形链表 II

题目LeetCode142. 环形链表 II

思路

本题的两个关键问题

• 如何判断链表有环？
• 如果有环，如何确定环的入口？

判断链表有环

• 如果链表为空或者链表只有一个节点，那么链表一定无环
• 如果链表有多个节点，可以通过快慢指针判断链表是否有环

定义快指针fast、满指针slow，快指针一次走2个节点，慢指针一次走一个节点，如果经过若干步、快慢指针的值相等(指向同一个节点)，那么链表一定有环

理论上来说如果一个链表有环，只需要保证快慢指针的速度差为1个节点，最终快慢指针的值一定会相等，所以这里快指针一次走3个节点、慢指针一次走2个节点也是可以的，但是这样的话可能会导致一次性越过链表尾节点，需要更多的条件来判断，所以这里使用快指针一次走2节点、慢指针一次走1节点是最合适的
注意：即使有环，快慢指针也不会在任何情况下都相遇，但是如果有环，快慢指针的速度差为1情况下一定会相遇

确定环的入口

在确定链表一定有环之后，接下来就该确定环的入口了。
假设从头结点到环形入口节点的节点数为x。 环形入口节点到 fast指针与slow指针相遇节点节点数为y。从相遇节点 再到环形入口节点节点数为 z。 如图所示：

慢指针经过的节点数为x+y,快指针经历的节点数为x+n(y+z)+y,其中n大于等于1因为快指针一定是在环内部走过了一圈才和慢指针相遇,由快指针的速度是慢指针的两倍，所以在相同的时间内有等式2(x+y)=x+n(y+z)+y，化简可得x=(n-1)(y+z)+z (n>=1)，该等式说明了头节点到环入口点和相遇点到环入口点距离之间的关系：头节点到入口点的距离等于相遇点到入口点距离加上环长度的整数倍。

为什么慢指针一定没有完整走过一圈就和快指针相遇了呢？
因为快指针一次走2步，慢指针一次走1步，它们的速度差为1，所以如果要相遇，一定会在慢指针走完第一圈之前相遇。如果这里定义慢指针一次走3步，快指针一次走2步，那么这个表达式就不成立了，需要另外的表达式。

代码

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
struct ListNode *detectCycle(struct ListNode *head) {
    typedef struct ListNode ListNode;
    //链表为空或者 只有一个节点一定无环
    if ( head == NULL || head->next == NULL) return NULL;
    
    ListNode* fast = head;
    ListNode* slow = head;
    //寻找快慢指针相遇点
    ListNode* index1;

    while (fast && fast->next)
    {
        fast = fast->next->next;
        slow = slow->next;
          if (fast == slow)
        {
            index1 = fast;
            break;
        }
    }
    //判断链表是否有环
    if (fast != slow)   return NULL;
    ListNode* index2 = head;
    int x = 0;//入口到头节点的距离
    int y = 0;//相遇点到入口的距离
    //找到环的入口点
   while (index1 != index2)
   {
       index1 = index1->next;
       index2 = index2->next;
   }
   return index1;
}

---