代码随想录算法训练营第四天|24.两两交换链表中的节点、19.删除链表的倒数第N个节点、160.链表相交、142.环形链表II

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

题目描述

题目链接：力扣24.两两交换链表中的节点

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

思路

将链表两两分组，则每一组应该是同样的处理方式。

交换两个相邻的节点共需三个变量，分别指向待交换的两个节点和他们前面的一个节点。

如此逻辑就很清晰了，只需要：

• p2 p3交换next指针
• p1 next指向p3
• p1 p2 p3指向下一组待交换节点

代码实现

/*
 * @lc app=leetcode.cn id=24 lang=cpp
 *
 * [24] 两两交换链表中的节点
 */

// @lc code=start
/**
 * 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* swapPairs(ListNode* head) {
        ListNode *vhead = new ListNode(0, head);
        ListNode *p1 = vhead;
        ListNode *p2 = p1->next;
        ListNode *p3;
        if(p2) p3 = p2->next;
        else return p2;

        if(!p3) return p2;

        while(p3){
            p2->next = p3->next;
            p1->next = p3;
            p3->next = p2;

            p1 = p2;
            p2 = p1->next;
            if(!p2) break;
            p3 = p2->next;
        } 
        return vhead->next;
    }
};
// @lc code=end

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

题目描述

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

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

思路

已知删除链表的某个节点只需要它前面一个节点的指针，那么若要找到倒数第N个节点，关键是需要一个指针指向倒数第N+1个节点。

我们需要前后两个指针，起始都指向head，前面的指针先走N步，然后两个指针再以同样的速度向后移动，当前面的指针走到末尾时，后面的指针刚好指向倒数第N+1个节点，之后正常进行删除操作即可。

代码实现

/*
 * @lc app=leetcode.cn id=19 lang=cpp
 *
 * [19] 删除链表的倒数第 N 个结点
 */

// @lc code=start
/**
 * 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 *p1 = head, *p2 = head;
        for(int i = 0; i < n; i++){
            p2 = p2->next;
        }
        if(!p2) return p1->next;
        while(p2->next){
            p1 = p1->next;
            p2 = p2->next;
        }
        p1->next = p1->next->next;
        return head;
    }
};
// @lc code=end

160.链表相交

题目描述

题目链接：力扣160.链表相交

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

思路

遍历第一个链表，同时使用哈希表存储经过的节点，再遍历第二个节点，同时查找哈希表，第一个查到的就是相交节点。

代码实现

/*
 * @lc app=leetcode.cn id=160 lang=cpp
 *
 * [160] 相交链表
 */

// @lc code=start
/**
 * 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) {
        map<ListNode*, int> record;
        ListNode *p = headA;
        while(p){
            record.insert(pair<ListNode*, int>(p, 1));
            p = p->next;
        }
        p = headB;
        while(p){
            if(record.find(p) != record.end()) return p;
            p = p->next;
        }
        return nullptr;
    }
};
// @lc code=end

142.环形链表II

题目描述

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

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

思路

假定链表有环，那么设入环前的长度为$a$，环的长度为$b$。我们给出两个快慢指针，同时从起点出发，快指针一次走两步，慢指针一次走一步，那么两个指针一定会在环内相遇。设快指针走过的路程为$s_1$，慢指针走过的路程为$s_2$。有如下关系式：

• $s_1=2s_2$
• $s_1-s_2=nb$
• $s_2=nb$

当我们推出$s_2=nb$时，问题就几乎解决了。我们知道从起点到环的入口共需$a$步，绕一圈回到入口则需$a+b$步，$a+2b$步，…，也就是$a+nb(n=0,1,2,\dots )$步。

那么知道两指针第一次相遇时，慢指针走了$nb$步，很明显让它再走a步就会回到入口节点。故让一个指针重新指向头节点head，两个指针以同样的速度走，第二次相遇时刚好走了$a$步，也就抵达了环的入口，返回即可。

代码实现

/*
 * @lc app=leetcode.cn id=142 lang=cpp
 *
 * [142] 环形链表 II
 */

// @lc code=start
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
        if(!head || !head->next) return NULL;

        ListNode *p1 = head, *p2 = head;
        while(p1 != p2){
            if(!p1 || !p2 || !p2->next) return NULL;
            p1 = p1->next;
            p2 = p2->next->next;
        }
        p2 = head;
        while(p1 != p2){
            p1 = p1->next;
            p2 = p2->next;
        }
        return p1;
    }
};
// @lc code=end