代码随想录算法训练营Day04

Day04 链表

一、力扣相关例题

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

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

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

解题关键：
一定要理解节点翻转的过程，参考视频
①操作的当前指针一定要指向反转两个节点的前一个节点
②循环终止条件：偶数：cur→next == NULL；奇数：cur→next→next==NULL
③定义临时变量储存中间的节点

class Solution {
public:
    ListNode* swapPairs(ListNode* head) {
        ListNode* nullhead = new ListNode(0);  //定义虚拟头节点
        nullhead->next = head;
        ListNode* cur = nullhead;
        while (cur->next != nullptr && cur->next->next != nullptr) {  //终止条件，节点为偶数、奇数的情况
            ListNode* temp = cur->next;        //临时指针保存cur当前指针的下一个节点
            ListNode* temp1 = cur->next->next->next;   //临时指针保存cur当前指针的下下下一个节点
            cur->next = cur->next->next;    //以前四个节点为例：虚拟→2
            cur->next->next = temp;         //2→1
            cur->next->next->next = temp1;  //1→3
            cur = cur->next->next;          //cur指向要调换顺序的两个节点前的一个节点
        }
        return nullhead->next;
    }
};

//主体代码少一个中间变量，大家可对照上一个代码，只是指向顺序不一样，最终运行的内存消耗也差不多
class Solution {
public:
    ListNode* swapPairs(ListNode* head) {
        ListNode* nullhead = new ListNode(0);  //定义虚拟头节点
        nullhead->next = head;
        ListNode* cur = nullhead;
        while (cur->next != nullptr && cur->next->next != nullptr) {  //终止条件，节点为偶数、奇数的情况
            ListNode* temp = cur->next;        //临时指针保存cur当前指针的下一个节点
            cur->next = cur->next->next;    //以前四个节点为例：虚拟→2
            temp->next = temp->next->next;  //1→3
            cur->next->next = temp;         //2→1
            cur = cur->next->next;          //cur指向要调换顺序的两个节点前的一个节点
        }
        return nullhead->next;
    }
};

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

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

示例 ：

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

解题关键：
①用双指针寻找到指定节点，删除该节点
②终止条件是快指针指向NULL
③快指针比满指针多走n+1步，因为要删除倒数n个节点，满指针需指向n-1个节点（这里要注意快指针走第n+1步时，快指针可能已经NULL了，小心编译出现空指针异常）

class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        ListNode* nullhead = new ListNode(0);
        nullhead->next = head;
        ListNode* fast = nullhead;
        ListNode* slow = nullhead;
        n++; //避免快指针走第n+1步的时候进行空指针操作
        while (n-- && fast != NULL) {   //快指针比满指针多走n+1步
            fast = fast->next;
        }
        while (fast != NULL) {       //快慢指针同时移动
            fast = fast->next;
            slow = slow->next; 
        }
        ListNode* temp = slow->next;  //临时指针保存删除节点位置
        slow->next = slow->next->next;
        delete temp;    //释放删除节点的内存
        return nullhead->next;
    }
};

160. 相交链表

给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表不存在相交节点，返回 null 。
题目数据 保证 整个链式结构中不存在环。
注意，函数返回结果后，链表必须 保持其原始结构 。

示例 ：

输入：intersectVal = 8, listA = [4,1,8,4,5], listB = [5,6,1,8,4,5], skipA = 2, skipB = 3
输出：Intersected at ‘8’
解释：相交节点的值为 8 （注意，如果两个链表相交则不能为 0）。
从各自的表头开始算起，链表 A 为 [4,1,8,4,5]，链表 B 为 [5,6,1,8,4,5]。
在 A 中，相交节点前有 2 个节点；在 B 中，相交节点前有 3 个节点。
— 请注意相交节点的值不为 1，因为在链表 A 和链表 B 之中值为 1 的节点 (A 中第二个节点和 B 中第三个节点) 是不同的节点。换句话说，它们在内存中指向两个不同的位置，而链表 A 和链表 B 中值为 8 的节点 (A 中第三个节点，B 中第四个节点) 在内存中指向相同的位置。

解题关键：
这道题刚我有点懵，题目描述的也不怎么明白易懂，我自身按照题目的理解：首先两个链表要后部对齐，比较前面是否有相交的点（两个链表数据相同不一定相交，要比较内存是否相同），若有相交则返回相交的点，若没有返回NULL
①双指针，一个curA指针指向A，一个curB指针指向B
②计算两个链表的长度，将长链表的临时指针与短链表的临时指针相对齐
③循环，比较curA是否等于curB

class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        ListNode* curA = headA;
        ListNode* curB = headB;
        if (headA == NULL || headB == NULL) {
            return NULL;
        }
        int lenA = 0, lenB = 0;
        while (curA != NULL) {
            curA = curA->next;
            lenA++;
        }
        while (curB != NULL) {
            curB = curB->next;
            lenB++;
        }
        //这里要重新指向头节点，否则进行空指针操作
        curA = headA;
        curB = headB;
        //统一让链表A为最长的链表，也可让B为最长的链表，看个人习惯
        if (lenB > lenA) {
            swap(lenA, lenB);  //调换AB长度
            swap(curA, curB);  //调换AB临时节点指针
        }
        int nn = lenA - lenB;  //nn为两个链表长度之差
        while (nn--) {         //将curA与curB对齐
            curA = curA->next;
        }
        while (curA != NULL && curB != NULL) {
            if (curA == curB) {
                return curA;
            }
            curA = curA->next;
            curB = curB->next;
        }
        return NULL;
    }
};

142. 环形链表 II

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

不允许修改 链表。

示例 ：

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

解题关键：
首先，题目的意思是输入的head[]、pos只是为了构造一个链表，让你写solution判断这个链表是否为环形链表，若是返回环的结点，否则返回NULL。
起初我搞不懂题目的意思，提醒一下大家

①双指针（快慢指针），若快指针与慢指针相遇，则链表有环；
②快指针的速度只能比慢指针快一个节点，否则快指针可能存在将慢指针跳过，而相遇不到
③如何判断以及建立条件得出两指针相遇的点，v(fast)=2，v(slow)=1，n>=1
2(x+y)= x+y+n(y+z)
x+y=n(y+z)
x=n(y+z)-y
x=(n-1)(y+z)+z
④由上述式子可以得出，若快慢指针相遇后，x=z
⑤定义临时指针index1，index2，则可得出环的起始点

class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
        ListNode* fast = head;
        ListNode* slow = head;
        while (fast != NULL && fast->next != NULL) {  //判断fast以及fast→next是否为空
            fast = fast->next->next;
            slow = slow->next;
            if (fast == slow) {  //快慢指针相遇
                ListNode* index1 = fast;
                ListNode* index2 = head;
                while (index1 != index2) {  //临时指针index1、index2找出环的起始点
                    index1 = index1->next;
                    index2 = index2->next;
                }
                return index1;
            }
        }
        return NULL;
    }
};

二、链表总结

1、链表的存储方式

链表是通过指针域的指针链接在内存中各个节点。
所以链表中的节点在内存中不是连续分布的 ，而是散乱分布在内存中的某地址上，分配机制取决于操作系统的内存管理。

2、链表的基本操作（参考707设计链表）

1. 获取链表第index个节点的数值
2. 在链表的最前面插入一个节点
3. 在链表的最后面插入一个节点
4. 在链表第index个节点前面插入一个节点
5. 删除链表的第index个节点的数值

3、题目总结

此为代码随想录知识星球成员海螺人总结！

链表章节，完结！撒花！
继续加油！