小白算法记录Day4|24. 两两交换链表中的节点、LeetCode 19.删除链表的倒数第N个节点、链表相交、LeetCode 142.环形链表II-CSDN博客

本文链接：https://blog.csdn.net/weixin_62268491/article/details/128273902

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

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

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

解题思路

利用制造出的虚拟头节点来改变头节点和次节点的指针顺序，并且依次将虚拟头节点往后顺延两个位置来实现题目要求。

struct ListNode* swapPairs(struct ListNode* head){
    typedef struct ListNode ListNode;
    ListNode * nhead = (ListNode*)malloc(sizeof(ListNode));//虚拟头节点
    ListNode * cur = nhead;
    cur->next = head;
    
    while (cur->next != NULL && cur->next->next != NULL) {
        ListNode * temp = cur->next;
        ListNode * temp1 = cur->next->next->next;
        cur->next = cur->next->next;
        cur->next->next = temp;
        temp->next = temp1;
        cur = cur->next->next;
    }
    return nhead->next;
}

难点

本题要画图才能好理解（图来源：代码随想录），设定一个虚拟头节点，按照以下图的顺序依次定义指针（包括虚拟节点在内需要定义四个指针），完成一个循环后，将虚拟头节点指针向后推两个位置，再次进行数值交换。

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

题目链接：19.删除链表的倒数第N个节点

题目描述：给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。

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

解题思路

本题要利用虚拟头节点外加双指针的操作来完成，快指针先移动n个单位，然后快慢指针同时移动直到快指针指向空，此时慢指针的指向则为要删除的节点。但是根据一般的链表删除经验都是找到删除节点的前一个位置。

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


struct ListNode* removeNthFromEnd(struct ListNode* head, int n){
    struct ListNode * nhead = malloc(sizeof(struct ListNode));
    struct ListNode * fast = nhead;
    struct ListNode * slow = nhead;
    nhead->next = head;
    
    for (int i = 0 ; i <= n ; i++) {
        fast = fast->next;
    }

    while (fast) {
        fast = fast->next;
        slow = slow->next;
    }
    slow->next = slow->next->next;
    head = nhead->next;
    free(nhead);
    return head;
}

难点

理解快慢指针的操作方法，快指针要先行n+1个单位，快慢指针再同时移动（这样才能保证慢指针指向的是待删除节点的前一个节点），直到快指针为空。

三、面试题02.07.链表相交

题目链接：面试题 02.07. 链表相交

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

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

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

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

输入：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 个节点。

解题思路

根据题意不难判断出，交点指针相等，我们可以将两条链表尾部对其，然后再从头寻找相交的元素。

/**
 * 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;
    ListNode * l = NULL;
    ListNode * s = NULL;
    int lenA = 0 , lenB = 0 , gap = 0;
    
    //求出两个链表的长度
    s = headA;
    while (s) {
        lenA++;
        s = s->next;
    }
    s = headB;
    while (s) {
        lenB++;
        s = s->next;
    }
    //长的定义为l，短的为s，长度差为gap
    if (lenA > lenB) {
        l = headA;
        s = headB;
        gap = lenA - lenB;
    }
    else {
        l = headB;
        s = headA;
        gap = lenB - lenA;
    }
    //尾部对齐
    while (gap--) {
        l = l->next;
    }
    //找出相交点
    while (l) {
        if (l == s) {
            return l;
        }
        else {
            l = l->next;
            s = s->next;
        }
    }
    return NULL;
}

难点

1.相交的点不是数值相等，而是指针相等；

2.求出两条链表的长度，并且求出长度差，在尾部对其的条件下找出对齐的指针位置，挨个寻找。

四、LeetCode 142.环形链表II

题目链接：142.环形链表II

题目描述：

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

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

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

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

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

解题思路

观察题目，这道题目有两个问题，是否有环，有的话返回环的初始位置，利用快慢指针方法来判断是否有环，快指针先行（本题中是快指针每次走两步，而慢指针每次走一步，快指针相对慢指针多走一步），如果链表有环的话，快慢指针一定会在某一个点相交。

此外，如果有环，如何找到这个环的入口？

我们根据上图来定义关键的长度，在相遇时（不难理解如果相遇的话，慢指针一定是处于环的第一圈没走完的状态），慢指针走过的距离是x+y，而快指针走过的距离则为x+y+n（y+z），可得出如下等式2（x+y）=x+y+n（y+z），可得出x=（n+1）（y+z）+z，其中圈数n是>=1的，代入极端情况，n=1时，x=z，即出发点到环的入口距离x等于相遇点到入口的距离z。

根据以上分析，列出以下代码

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
struct ListNode *detectCycle(struct ListNode *head) {
    typedef struct ListNode ListNode;
    ListNode * fast = head;
    ListNode * slow = head;
    while (fast != NULL && fast->next != NULL) {
        slow = slow->next;
        fast = fast->next->next;
        if (fast == slow) {
            ListNode * index1 = head;
            ListNode * index2 = fast;
            while (index1 != index2) {
                index1 = index1->next;
                index2 = index2->next;
            }
            return index1;
        }
    }
    return NULL;
}