【算法训练 day4 两两交换链表中的节点、删除链表的倒数第N个节点、链表相交、环形链表Ⅱ】

---

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

Leecode链接: leetcode 24
文章链接: 代码随想录
视频链接: B站

给定一个链表，两两交换其中相邻的节点，并返回交换后的链表。

你不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。

示例：

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

思路

看到返回头节点并且对原有的链表进行修改，考虑使用虚拟头节点以及双指针。

实现代码

//cpp
class Solution {
public:
    ListNode* swapPairs(ListNode* head) {
        if(head == nullptr) return head;//空链表直接返回本身

        ListNode* vhead = new ListNode();
        vhead->next = head;
        ListNode* cur = vhead;

        while(cur->next&&cur->next->next){
            ListNode* slow = cur->next;
            ListNode* fast = slow->next;

            cur->next = fast;
            slow->next = fast->next;
            fast->next = slow;
            cur = slow;
        }
        ListNode* res = vhead->next;
        delete vhead;
        vhead = nullptr;
        return res;
    }
};

个人问题

题目描述的很模糊，没有说明数组中奇数个数的元素该如何交换，在while循环的条件上犹豫很久，按照题意，三个元素只需交换前两个即可退出循环。

总结

整体比较简单，算法时间复杂度为O(n)，空间复杂度为O(1)。

---

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

Leecode链接: LeetCode 19
文章链接: 代码随想录
视频链接: B站

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

示例：

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

思路

返回链表头节点，使用虚拟头节点以及双指针，快指针初始化在虚拟头节点位置并优先移动n位，慢指针初始化在虚拟头节点位置，然后快慢指针遍历，直到快指针到链表结尾时，慢指针的指向即为所需要删除节点的前一个节点。

实现代码

//cpp
class Solution
{
public:
    ListNode *removeNthFromEnd(ListNode *head, int n)
    {
        ListNode* vhead = new ListNode();//虚拟头节点

        vhead->next = head;
        ListNode* fast = vhead;
        ListNode* slow = vhead;

        while(n--){
            fast = fast->next;
        }
        while(fast->next){//条件成立时，slow为删除节点的前一个节点
            fast = fast->next;
            slow = slow->next;
        }

        slow->next = slow->next->next;

        ListNode* res = vhead->next;

        delete vhead;
        vhead = nullptr;
        return res;
    }
};

个人问题

在实现代码时，最初快慢指针初始化为head，但没有考虑到链表只有一个元素的情况，出现未定义行为，将快慢指针初始化为虚拟头节点后解决问题。

总结

题目有一定技巧性，时间复杂度O(n)，空间复杂度为O(1)。

---

三.链表相交-LeeCode 160

Leecode链接: LeetCode 160
文章链接: 代码随想录

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

示例：

输入：intersectVal = 2, listA = [0,9,1,2,4], listB = [3,2,4], skipA = 3, skipB = 1
输出：Intersected at '2'
解释：相交节点的值为 2 （注意，如果两个链表相交则不能为 0）。
从各自的表头开始算起，链表 A 为 [0,9,1,2,4]，链表 B 为 [3,2,4]。
在 A 中，相交节点前有 3 个节点；在 B 中，相交节点前有 1 个节点。

思路

判断是否有交点，需要判断指针以及节点的值是否相同。由于两个链表可能长度不一致，并且可以看到链表相交后面的节点完全一致，我们考虑将两个链表末尾对齐，以较短的那个链表的头节点为起点，同时遍历，直到找到一个值相同且地址相同的节点

实现代码

//cpp
class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        int a = 0;
        int b = 0;
        int sub = 0;//两个链表的差

        ListNode* p1 = headA;
        ListNode* p2 = headB;
		
		//计算A长度
        while(p1){
            p1 = p1->next;
            a++;
        }
        //计算B长度
        while(p2){
            p2 = p2->next;
            b++;
        }
        
		//根据长度提前将指针移动到同一起点
        if(a>b){
            sub = a-b;
            p1 = headA;
            p2 = headB;
            while(sub--){
                p1 = p1->next;
            }
        }
        else{
            sub = b-a;
            p1 = headA;
            p2 = headB;
            while(sub--){
                p2 = p2->next;
            }
        }
		
		//同时遍历各自链表，直到找到相同节点退出循环
        while(p1){
            if((p1 == p2)&&(p1->val == p2->val)){
                return p1;
            }
            p1 = p1->next;
            p2 = p2->next;
        }
        return NULL;
    }
};

个人问题

直接看题目没有写出，看题解直接一次通过。

总结

题目具有一定技巧性。时间复杂度O(n+m),空间复杂度O(1)。

---

四.环形链表Ⅱ-LeeCode 142

Leecode链接: LeetCode 142
文章链接: 代码随想录
视频链接: B站

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

为了表示给定链表中的环，使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。 如果 pos 是 -1，则在该链表中没有环。

说明：不允许修改给定的链表。

思路

首先判断是否存在环，如果有环，使用双指针，让快指针先进入环中每次移动两个节点，慢指针每次移动一个节点，那么慢指针与快指针必定会相遇，可以理解成操场跑步的追击问题，循环追击一定会相遇。如果确定有环，相遇地点的确定需要通过数学推导进行判断。

实现代码

class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
        ListNode* fast = head;
        ListNode* slow = head;

        while(fast->next&&slow->next){
            fast = fast->next->next;//每次移动两个节点
            slow = slow->next;//每次移动一个节点
			
			//如果相等代表有环
            if(fast == slow){
                ListNode* p1 = head;
                ListNode* p2 = fast;

                while(p1 != p2){
                    p1 = p1->next;
                    p2 = p2->next;
                }
                return p1;
            }
        }
        return NULL;
    }
};

个人问题

没有写出代码，看了题解才能通过。

总结

题目具有一定的数学性，需要自己在纸上进行推导才能理解过程。