代码随想录算法训练营第四天 |-链表篇24&19&02.07&142

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

题目&难度

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

难度：中等

示例

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

算法——虚拟头节点

题目不难，只要设定虚拟头节点进行模拟就好。

这里要知道的是cur永远指向需要操作的一对节点的前一个节点。

例如现在有奇数个节点，此时如下操作。

还要注意一点，就是**循环不变量中必须先写cur->next != NULL再写cur->next->next! = NULL，不能反过来。**因为当反过来的话，会先判断cur->next->next但是当cur->next已经为NULL时，就会报空指针错误。

直接上代码，注释详细：

struct ListNode* ListNodeCreate(){
    struct ListNode* head = (struct ListNode*)malloc(sizeof(struct ListNode));
    head->next = NULL;
    return head;
}


//二刷代码
struct ListNode* swapPairs(struct ListNode* head){
    struct ListNode* dummyHead = (struct ListNode*)malloc(sizeof(struct ListNode));
    struct ListNode* cur = (struct ListNode*)malloc(sizeof(struct ListNode));
    dummyHead->next = head;
    cur = dummyHead;

    //开始遍历
    while(cur->next != NULL && cur->next->next != NULL){
        //将节点一保存
        struct ListNode* temp = cur->next;
        //保存节点3
        struct ListNode* temp1 = cur->next->next->next;

        /*开始操作*/
        //把cur指向下一波要操作节点3，4前的一个节点
        cur->next = cur->next->next;
        //将节点2指向节点1
        cur->next->next = temp;
        //节点1下一个节点指向节点3
        temp->next = temp1;
        //cur指向节点1
        cur =  cur->next->next;
    }
    //返回头节点
    return dummyHead->next;
}

复杂度分析

时间复杂度：O(n)

空间复杂度：O(1)

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

题目&难度

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

示例

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

struct ListNode* removeNthFromEnd(struct ListNode* head, int n){
    struct ListNode* dummyHead = (struct ListNode*)malloc(sizeof(struct ListNode));
    dummyHead->val = 0;
    dummyHead->next = head;

    struct ListNode* fast = dummyHead;
    struct ListNode* slow = dummyHead;
    
    //快指针需要往前走n+1步
    for(int i = 0; i < (n + 1); i++){
        fast = fast->next;
    }

    //双指针同时前进
    while(fast){
        fast = fast->next;
        slow = slow->next;
    }    
    //删除节点操作
    slow->next = slow->next->next;
    
    return dummyHead->next;
    free(dummyHead);
}

不难，注意边界条件就好。

面试题02.07.——链表相交

题目&难度

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

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

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

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

难度：简单。

示例

算法——双指针法

交点不是数值相等，而是指针相等。

struct ListNode *getIntersectionNode(struct ListNode *headA, struct ListNode *headB) {
    //定义两个链表的长度
    int lengthA = 0;
    int lengthB = 0;
    
    //双指针
    struct ListNode* a = headA;
    struct ListNode* b = headB;

    while(a){
        a = a->next;
        lengthA++;
    } 
    while(b){
        b= b->next;
        lengthB++;
    }
    //让两个指针同时到起始位置
    a = headA;
    b = headB;

    //两个链表的长度差
    int sub = 0;

    if (lengthA > lengthB) {
        //a = headA;
        //b = headB;
        sub = lengthA - lengthB;
    } else {
        a = headB;
        b = headA;
        sub = lengthB - lengthA;
    }

    //求两个链表长度的差值
    //int sub = lengthA - lengthB;
    //长链表先走差距步，让curA和curB在同一起点上（末尾位置对齐）
    while(sub){
        a = a->next;
        sub--;
    }
    while(a){
        if(a = b){
            return a;
        }
        a = a->next;
        b = b->next;
    }
    return NULL;

}

提交结果：

嘶……为什么呢……

哎哟哦我去，原来是44行判定少了一个等号，怪不得了！岂可休！以后要多多注意啊！

链表142——环形链表Ⅱ

题目&难度

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

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

不允许修改 链表

示例

算法——双指针法

话不多说，一下参考卡尔老师的思路：（纯引用）

fast和slow各自再走一步， fast和slow就相遇了

这是因为fast是走两步，slow是走一步，其实相对于slow来说，fast是一个节点一个节点的靠近slow的，所以fast一定可以和slow重合。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-7P1yeotl-1682516049357)(D:\为学\求职\华为机试\记录博客文档\训练营打卡作业\第四次打卡-链表篇图片\9.png)]

(x + y) * 2 = x + y + n (y + z)

两边消掉一个（x+y）: x + y = n (y + z)

因为要找环形的入口，那么要求的是x，因为x表示 头结点到 环形入口节点的的距离。

所以要求x ，将x单独放在左面：x = n (y + z) - y ,

再从n(y+z)中提出一个 （y+z）来，整理公式之后为如下公式：x = (n - 1) (y + z) + z 注意这里n一定是大于等于1的，因为 fast指针至少要多走一圈才能相遇slow指针。

这个公式说明什么呢？

先拿n为1的情况来举例，意味着fast指针在环形里转了一圈之后，就遇到了 slow指针了。

当 n为1的时候，公式就化解为 x = z，

这就意味着，从头结点出发一个指针，从相遇节点 也出发一个指针，这两个指针每次只走一个节点， 那么当这两个指针相遇的时候就是 环形入口的节点。

也就是在相遇节点处，定义一个指针index1，在头结点处定一个指针index2。

让index1和index2同时移动，每次移动一个节点， 那么他们相遇的地方就是 环形入口的节点。

那么 n如果大于1是什么情况呢，就是fast指针在环形转n圈之后才遇到 slow指针。

其实这种情况和n为1的时候 效果是一样的，一样可以通过这个方法找到 环形的入口节点，只不过，index1 指针在环里 多转了(n-1)圈，然后再遇到index2，相遇点依然是环形的入口节点。

struct ListNode *detectCycle(struct ListNode *head) {
    //更新两个指针，起始位置均在头节点
    struct ListNode *fast=head;
    struct ListNode *slow=head;

    //fast指针每次前进两步，因此要看fast->next是否为空
    while(fast!=NULL && fast->next!=NULL){
        
        //快慢指针开始前进
        fast=fast->next->next;
        slow=slow->next;

        //相遇
        if(fast==slow){
            struct ListNode *index1=fast;//这里是相遇的点；这里写成slow也可以
            struct ListNode *index2=head;//从头部出发

            //终止条件
            while(index1!=index2){

                index1=index1->next;
                index2=index2->next;

            }return index1;//返回相遇点；写成index2也可以
        }
    }return NULL;//若没相遇，找不到就返回NULL
}