【算法】代码随想录刷题记录 | 2. 链表篇

已于 2024-01-09 15:50:41 修改
阅读量839 收藏 17
点赞数 28
分类专栏： 算法 文章标签： c++ 算法 leetcode
于 2024-01-08 18:46:34 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Conner7/article/details/135283807
版权

理论基础

数组是在内存中是连续分布的，但是链表在内存中不是连续分布的。

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

链表节点的定义的写法需要牢记。

平时在刷leetcode的时候，链表的节点都默认定义好了，直接用就行了，所以很多人都没有注意到链表的节点是如何定义的。而在面试的时候，一旦要自己手写链表，就写的错漏百出。

C/C++的定义链表节点方式如下所示：

// 单链表
struct ListNode {
    int val;  // 节点上存储的元素
    ListNode *next;  // 指向下一个节点的指针
    ListNode(int x) : val(x), next(NULL) {}  // 节点的构造函数
};

删除节点

删除D节点，如图所示：

链表-删除节点

只要将C节点的next指针 指向E节点就可以了。

在C++里最好是再手动释放这个D节点，释放这块内存。

其他语言例如Java、Python，有自己的内存回收机制，不用自己手动释放。

添加节点

如图所示：

链表-添加节点

可以看出链表的增添和删除都是O(1)操作，也不会影响到其他节点。

但是要注意，要是删除第五个节点，需要从头节点查找到第四个节点通过next指针进行删除操作，查找的时间复杂度是O(n)。

链表与数组的比较：

链表-链表与数据性能对比

数组在定义的时候，长度就是固定的，如果想改动数组的长度，就需要重新定义一个新的数组。

链表的长度可以是不固定的，并且可以动态增删， 适合数据量不固定，频繁增删，较少查询的场景。

203. 移除链表元素

题目链接

思路：

主要是虚拟头节点dummyHead的使用，以及使用C++时记得清理被删除的节点内存。

203_链表删除元素1

如果使用C++编程语言的话，不要忘了还要从内存中删除这两个移除的节点， 清理节点内存之后如图：

203_链表删除元素2

题解：

class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {
        ListNode* dummyHead = new ListNode(-1, head);
        ListNode* cur = dummyHead;
        ListNode* temp;
        while (cur != nullptr && cur->next != nullptr) {
            if (cur->next->val == val) {
                temp = cur->next;
                cur->next = cur->next->next;
                delete temp;
            } else {
                cur = cur->next;
            }
        }
        head = dummyHead->next;
        delete dummyHead;
        return head;
    }
};

707. 设计链表

题目链接

思路：

这题按照代码随想录里的虚拟头节点思路写的，即自己定义链表，但由于LeetCode已经给出过结构体定义，这样写在LeetCode中无法运行。

官解1：

//代码随想录解答
class MyLinkedList {
public:
    // 定义链表节点结构体
    struct LinkedNode {
        int val;
        LinkedNode* next;
        LinkedNode(int val):val(val), next(nullptr){}
    };

    // 初始化链表
    MyLinkedList() {
        _dummyHead = new LinkedNode(0); // 这里定义的头结点 是一个虚拟头结点，而不是真正的链表头结点
        _size = 0;
    }

    // 获取到第index个节点数值，如果index是非法数值直接返回-1， 注意index是从0开始的，第0个节点就是头结点
    int get(int index) {
        if (index > (_size - 1) || index < 0) {
            return -1;
        }
        LinkedNode* cur = _dummyHead->next;
        while(index--){ // 如果--index 就会陷入死循环
            cur = cur->next;
        }
        return cur->val;
    }

    // 在链表最前面插入一个节点，插入完成后，新插入的节点为链表的新的头结点
    void addAtHead(int val) {
        LinkedNode* newNode = new LinkedNode(val);
        newNode->next = _dummyHead->next;
        _dummyHead->next = newNode;
        _size++;
    }

    // 在链表最后面添加一个节点
    void addAtTail(int val) {
        LinkedNode* newNode = new LinkedNode(val);
        LinkedNode* cur = _dummyHead;
        while(cur->next != nullptr){
            cur = cur->next;
        }
        cur->next = newNode;
        _size++;
    }

    // 在第index个节点之前插入一个新节点，例如index为0，那么新插入的节点为链表的新头节点。
    // 如果index 等于链表的长度，则说明是新插入的节点为链表的尾结点
    // 如果index大于链表的长度，则返回空
    // 如果index小于0，则在头部插入节点
    void addAtIndex(int index, int val) {

        if(index > _size) return;
        if(index < 0) index = 0;        
        LinkedNode* newNode = new LinkedNode(val);
        LinkedNode* cur = _dummyHead;
        while(index--) {
            cur = cur->next;
        }
        newNode->next = cur->next;
        cur->next = newNode;
        _size++;
    }

    // 删除第index个节点，如果index 大于等于链表的长度，直接return，注意index是从0开始的
    void deleteAtIndex(int index) {
        if (index >= _size || index < 0) {
            return;
        }
        LinkedNode* cur = _dummyHead;
        while(index--) {
            cur = cur ->next;
        }
        LinkedNode* tmp = cur->next;
        cur->next = cur->next->next;
        delete tmp;
        //delete命令指示释放了tmp指针原本所指的那部分内存，
        //被delete后的指针tmp的值（地址）并非就是NULL，而是随机值。也就是被delete后，
        //如果不再加上一句tmp=nullptr,tmp会成为乱指的野指针
        //如果之后的程序不小心使用了tmp，会指向难以预想的内存空间
        tmp=nullptr;
        _size--;
    }

    // 打印链表
    void printLinkedList() {
        LinkedNode* cur = _dummyHead;
        while (cur->next != nullptr) {
            cout << cur->next->val << " ";
            cur = cur->next;
        }
        cout << endl;
    }
private:
    int _size;
    LinkedNode* _dummyHead;

};

官解2：

//LeetCode官方解答
class MyLinkedList {
public:
    MyLinkedList() {
        this->size = 0;
        this->head = new ListNode(0);
    }
    
    int get(int index) {
        if (index < 0 || index >= size) {
            return -1;
        }
        ListNode *cur = head;
        for (int i = 0; i <= index; i++) {
            cur = cur->next;
        }
        return cur->val;
    }
    
    void addAtHead(int val) {
        addAtIndex(0, val);
    }
    
    void addAtTail(int val) {
        addAtIndex(size, val);
    }
    
    void addAtIndex(int index, int val) {
        if (index > size) {
            return;
        }
        index = max(0, index);
        size++;
        ListNode *pred = head;
        for (int i = 0; i < index; i++) {
            pred = pred->next;
        }
        ListNode *toAdd = new ListNode(val);
        toAdd->next = pred->next;
        pred->next = toAdd;
    }
    
    void deleteAtIndex(int index) {
        if (index < 0 || index >= size) {
            return;
        }
        size--;
        ListNode *pred = head;
        for (int i = 0; i < index; i++) {
            pred = pred->next;
        }
        ListNode *p = pred->next;
        pred->next = pred->next->next;
        delete p;
    }
private:
    int size;
    ListNode *head;
};

作者：力扣官方题解
链接：https://leetcode.cn/problems/design-linked-list/solutions/1840997/she-ji-lian-biao-by-leetcode-solution-abix/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

206. 反转链表

思路：

这题做得多了几乎都背下来了，循环里前两句带"->next"，后两句更新语句不带。^^

题解：

class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        ListNode* prev = nullptr;
        ListNode* cur = head;
        while (cur != nullptr) {
            ListNode* next = cur->next;
            cur->next = prev;
            prev = cur;
            cur = next;
        }
        return prev;
    }
};

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

题目链接

思路：

建议使用虚拟头结点，这样会方便很多，要不然每次针对头结点（没有前一个指针指向头结点），还要单独处理。

可以通过画图来明确操作内容和先后顺序。

初始时，cur指向虚拟头结点，然后进行如下三步：

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

题解：

class Solution {
public:
    ListNode* swapPairs(ListNode* head) {
        ListNode* dummtHead = new ListNode(-1,head);
        ListNode* prev = dummtHead;
        while (prev->next != nullptr && prev->next->next != nullptr) {
            ListNode* cur = prev->next;
            ListNode* next = cur->next;
            ListNode* nextNext = next->next;
            prev->next = next;
            prev->next->next = cur;
            prev->next->next->next = nextNext;
            prev = prev->next->next;
        }
        ListNode* ans = dummtHead->next;
        delete dummtHead;
        return ans;
    }
};

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

题目链接

思路：

双指针的经典应用，如果要删除倒数第n个节点，让fast移动n步，然后让fast和slow同时移动，直到fast指向链表末尾。删掉slow所指向的节点就可以了。

要注意一些细节，比如最好使用虚拟头节点，删除一个节点需要知道上一个节点的next指针域。

题解：

class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        if (head == nullptr || head->next == nullptr) {
            return nullptr;
        }
        ListNode* dummyHead = new ListNode(-1, head);
        ListNode* slow = dummyHead;
        ListNode* fast = dummyHead;
        while(n--) {
            fast = fast->next;
        }
        while (fast != nullptr && fast->next != nullptr) {
            slow = slow->next;
            fast = fast->next;
        }
        ListNode* temp = slow->next;
        slow->next = slow->next->next;
        delete temp;
        ListNode* ans = dummyHead->next;
        delete dummyHead;
        return ans;
    }
};

面试题 02.07. 链表相交

题目链接

思路：

方法一：哈希表

方法二：双指针

首先求出两个链表的长度，并求出两个链表长度的差值，然后让curA移动到，和curB 末尾对齐的位置，如图：

面试题02.07.链表相交_2

此时就可以比较curA和curB是否相同，如果不相同，同时向后移动curA和curB，如果遇到curA == curB，则找到交点。否则循环退出返回空指针。

一个技巧是可以当lenA < lenB时，交换lenA、lenB以及curA、curB，使得A始终是更长的链表。

题解：

//方法一：哈希表
class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        unordered_set<ListNode*> set;
        ListNode* temp = headA;
        while (temp != nullptr) {
            set.insert(temp);
            temp = temp->next;
        }
        temp = headB;
        while (temp != nullptr) {
            if (set.find(temp) != set.end()) {
                return temp;
            }
            temp = temp->next;
        }
        return nullptr;
    }
};

//方法二：双指针
class Solution {
public:
    int getListLength (ListNode* head) {
        int count = 0;
        while (head != nullptr) {
            count++;
            head = head->next;
        }
        return count;
    }
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        int lenA = getListLength(headA);
        int lenB = getListLength(headB);
        ListNode* curA = headA;
        ListNode* curB = headB;
        if (lenA < lenB) {
            swap(lenA, lenB);
            swap(curA, curB);
        }
        int gap = lenA - lenB;
        while(gap--) {
            curA = curA->next;
        }
        while (curA != nullptr) {
            if (curA == curB) {
                return curA;
            }
            curA = curA->next;
            curB = curB->next;
        }
        return nullptr;
    }
};

142. 环形链表Ⅱ

题目链接

思路：

判断链表是否有环

可以使用快慢指针法，分别定义 fast 和 slow 指针，从头结点出发，fast指针每次移动两个节点，slow指针每次移动一个节点，如果 fast 和 slow指针在途中相遇 ，说明这个链表有环。

fast指针和slow指针一定会在环中相遇！

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

动画如下：

141.环形链表

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

此时已经可以判断链表是否有环了，那么接下来要找这个环的入口了。

假设从头结点到环形入口节点 的节点数为x。 环形入口节点到 fast指针与slow指针相遇节点 节点数为y。 从相遇节点 再到环形入口节点节点数为 z。 如图所示：

那么相遇时： slow指针走过的节点数为: x + y， fast指针走过的节点数：x + y + n (y + z)，n为fast指针在环内走了n圈才遇到slow指针， （y+z）为 一圈内节点的个数A。

因为fast指针是一步走两个节点，slow指针一步走一个节点， 所以 fast指针走过的节点数 = slow指针走过的节点数 * 2：

(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同时移动，每次移动一个节点， 那么他们相遇的地方就是 环形入口的节点。

动画如下：

142.环形链表II（求入口）

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

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

题解：

class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
        ListNode* fast = head;
        ListNode* slow = head;
        while (fast != nullptr && fast->next != nullptr) {
            fast = fast->next->next;
            slow = slow->next;
            if (fast == slow) {
                ListNode* ans = head;
                while (ans != slow) {
                    ans = ans->next;
                    slow = slow->next;
                }
                return ans;
            }
        }
        return nullptr;
    }
};

总结感悟

虚拟头结点

链表的一大问题就是操作当前节点必须要找前一个节点才能操作。这就造成了，头结点的尴尬，因为头结点没有前一个节点了。

每次对应头结点的情况都要单独处理，所以使用虚拟头结点的技巧，就可以解决这个问题。

反转链表

背熟了捏~

删除倒数第N个节点

结合虚拟头结点和双指针法来移除链表倒数第N个节点。

环形链表

找环的入口的主要难点在于数学证明。

稍敛风翼
关注
  • 28
    点赞
  • 踩
  • 17
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构与算法的刷题leetcode和学习.zip
01-15
算法分类：排序算法（如冒泡排序、快速排序、归并排序），查找算法（如顺序查找、二分查找、哈希查找），图论算法（如Dijkstra最短路径算法、Floyd-Warshall算法、Prim最小生成树算法），动态规划，贪心算法，回溯法...
用Java实现基础数据结构，排序算法、经典算法以及leetcode刷题记录.zip
01-15
算法分类：排序算法（如冒泡排序、快速排序、归并排序），查找算法（如顺序查找、二分查找、哈希查找），图论算法（如Dijkstra最短路径算法、Floyd-Warshall算法、Prim最小生成树算法），动态规划，贪心算法，回溯法...
【算法】代码随想录刷题记录 | 4. 字符串篇（含KMP算法详细步骤及代码）
Conner7的博客
01-11 1321
刷代码随想录LeetCode题的一些记录和感想（字符串篇）
代码随想录刷题｜一刷总结
东东唯一指定铲屎官
04-21 938
成果汇报经验总结为什么要刷题未来计划以及附件资源，里面有所有pdf，需要自取。我会在末尾放上pdf，点击思维导图的右上角的【箭头】可以直接跳转到leetcode，提供一键跳转方便复习。
【算法】代码随想录刷题记录 | 5. 栈与队列篇
Conner7的博客
01-17 880
刷代码随想录LeetCode题的一些记录和感想（栈与队列篇）
【算法】代码随想录刷题记录 | 6. 二叉树篇（上）
Conner7的博客
03-13 1298
刷代码随想录LeetCode题的一些记录和感想（二叉树篇（上））
代码随想录刷题|数组、链表的总结
symdunstaz的博客
10-17 147
数组和链表的总结
代码随想录刷题班|day3|第二章 链表
haozits_的博客
03-18 66
算法
代码随想录刷题记录：链表篇
qq_53324833的博客
01-17 402
前言 本篇为代码随想录的第二篇，链表篇。 203. 移除链表元素 题目描述： 思路： LeetCode这个题还是有很多陷阱的，我之前写过类似的一遍就过了而这次栽了很多坑。 首先我们要知道要删除的值可能有很多个，其次要知道头结点也可能是我们要删除的节点，也有可能在头结点之后几个节点都是我们要删除的，最后要记得我们的最后一个节点也可能是我们要删除的。 综上，代码如下，注释很详尽了： /** * Definition for singly-linked list. * public class ListNo
代码随想录刷题-链表-相交链表
夏日 の blog
03-17 760
代码随想录刷题-链表-相交链表总结
代码随想录刷题|LeetCode 332.重新安排行程 51. N皇后 37. 解数独
symdunstaz的博客
11-10 152
332.重新安排行程 51. N皇后 37. 解数独
LeetCode刷题笔记——19. 删除链表的倒数第N个节点
12-21
2、代码实现 # Definition for singly-linked list. # class ListNode: # def __init__(self, x): # self.val = x # self.next = None class Solution: def removeNthFromEnd(self, head: ListNode
大厂算法和数据结构刷题班.zip
12-30
算法代码：我们提供了多种数据结构的实现代码，包括数组、链表、栈、队列、树、图等。这些代码不仅能帮助你理解数据结构的基本概念，而且能让你明白如何在实际情况中应用这些数据结构。 笔记：详细且系统的笔记，...
C语言 指定一个数字输出区间内的一个斐波那契数列
Random_N1的博客
06-20 370
/ 函数用于计算并打印从1到n的斐波那契数列a = b;b = next;int num;return 0;
C/C++ 提取DNS请求/响应数据包之中的 Quesion 内容
liulilittle的博客
06-20 310
它主要是提取DNS数据包之中查询问题的信息，如：问题类型、问题类别、问题内容（域/IP），我们如果想要对于某个DNS数据包需要进行遥测的时，或者进行NS缓存生命周期管理，那么就需要类似这样的函数实现了。
线程简介及其函数使用实例（gcc *.c -lpthread）
CSDN_DU666666的博客
06-20 407
线程概念、线程接口提供方式、线程创建使用到的函数、多线程创建实例 、多线程创建实例 、多线程执行顺序问题和多线程占用内存问题
LeetCode 算法：两两交换链表中的节点 c++
最新发布
小金牛来了
06-20 928
LeetCode 算法：两两交换链表中的节点 c++
[宫水三叶的刷题日记]：链表1
08-03
宫水三叶的刷题日记中的这一篇是关于链表操作的，具体是删除链表的倒数第n个节点。从目标出发，我们需要确定倒数第n个节点的位置，而为了找到倒数第n个节点，我们可以利用双指针的思想。 首先，我们定义两个指针 ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值