Day3-链表_基础内容

自律先锋

于 2024-05-15 20:32:10 发布

阅读量883

点赞数 27

文章标签：算法数据结构 c++ 链表

本文链接：https://blog.csdn.net/weixin_51540495/article/details/138922467

版权

今日任务

● 链表理论基础

● 203.移除链表元素

● 707.设计链表

● 206.反转链表

详细布置

链表理论基础

建议：了解一下链接基础，以及链表和数组的区别

文章链接

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

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

有同学说了，我不定义构造函数行不行，答案是可以的，C++默认生成一个构造函数。

但是这个构造函数不会初始化任何成员变量，下面我来举两个例子：

通过自己定义构造函数初始化节点：

 ListNode* head = new ListNode(5);

使用默认构造函数初始化节点：

 ListNode* head = new ListNode();
 head->val = 5;

所以如果不定义构造函数使用默认构造函数的话，在初始化的时候就不能直接给变量赋值！

203.移除链表元素

建议：本题最关键是要理解虚拟头结点的使用技巧，这个对链表题目很重要。

题目链接/文章讲解/视频讲解

直接使用原来的链表来进行移除节点操作：

 class Solution {
 public:
     ListNode* removeElements(ListNode* head, int val) {
         // 删除头结点
         while (head != NULL && head->val == val) { // 注意这里不是if
             ListNode* tmp = head;
             head = head->next;
             delete tmp;
         }
 
         // 删除非头结点
         ListNode* cur = head;
         while (cur != NULL && cur->next!= NULL) {
             if (cur->next->val == val) {
                 ListNode* tmp = cur->next;
                 cur->next = cur->next->next;
                 delete tmp;
             } else {
                 cur = cur->next;
             }
         }
         return head;
     }
 };

时间复杂度: O(n)
空间复杂度: O(1)

设置一个虚拟头结点在进行移除节点操作：

 class Solution {
 public:
     ListNode* removeElements(ListNode* head, int val) {
         ListNode* dummyHead = new ListNode(0); // 设置一个虚拟头结点
         dummyHead->next = head; // 将虚拟头结点指向head，这样方便后面做删除操作
         ListNode* cur = dummyHead;
         while (cur->next != NULL) {
             if(cur->next->val == val) {
                 ListNode* tmp = cur->next;
                 cur->next = cur->next->next;
                 delete tmp;
             } else {
                 cur = cur->next;
             }
         }
         head = dummyHead->next;
         delete dummyHead;
         return head;
     }
 };

时间复杂度: O(n)
空间复杂度: O(1)

707.设计链表

建议：这是一道考察链表综合操作的题目，不算容易，可以练一练使用虚拟头结点

题目链接/文章讲解/视频讲解

下面采用的设置一个虚拟头结点（这样更方便一些，大家看代码就会感受出来）。

 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;
 
 };

时间复杂度: 涉及 index 的相关操作为 O(index), 其余为 O(1)
空间复杂度: O(n)

206.反转链表

建议先看我的视频讲解，视频讲解中对反转链表需要注意的点讲的很清晰了，看完之后大家的疑惑基本都解决了。

题目链接/文章讲解/视频讲解

首先定义一个cur指针，指向头结点，再定义一个pre指针，初始化为null。

然后就要开始反转了，首先要把 cur->next 节点用tmp指针保存一下，也就是保存一下这个节点。

为什么要保存一下这个节点呢，因为接下来要改变 cur->next 的指向了，将cur->next 指向pre ，此时已经反转了第一个节点了。

接下来，就是循环走如下代码逻辑了，继续移动pre和cur指针。

最后，cur 指针已经指向了null，循环结束，链表也反转完毕了。此时我们return pre指针就可以了，pre指针就指向了新的头结点。

双指针法

 class Solution {
 public:
     ListNode* reverseList(ListNode* head) {
         ListNode* temp; // 保存cur的下一个节点
         ListNode* cur = head;
         ListNode* pre = NULL;
         while(cur) {
             temp = cur->next;  // 保存一下 cur的下一个节点，因为接下来要改变cur->next
             cur->next = pre; // 翻转操作
             // 更新pre 和 cur指针
             pre = cur;
             cur = temp;
         }
         return pre;
     }
 };

时间复杂度: O(n)
空间复杂度: O(1)

递归法

递归法相对抽象一些，但是其实和双指针法是一样的逻辑，同样是当cur为空的时候循环结束，不断将cur指向pre的过程。

关键是初始化的地方，可能有的同学会不理解，可以看到双指针法中初始化 cur = head，pre = NULL，在递归法中可以从如下代码看出初始化的逻辑也是一样的，只不过写法变了。

具体可以看代码（已经详细注释），双指针法写出来之后，理解如下递归写法就不难了，代码逻辑都是一样的。

 class Solution {
 public:
     ListNode* reverse(ListNode* pre,ListNode* cur){
         if(cur == NULL) return pre;
         ListNode* temp = cur->next;
         cur->next = pre;
         // 可以和双指针法的代码进行对比，如下递归的写法，其实就是做了这两步
         // pre = cur;
         // cur = temp;
         return reverse(cur,temp);
     }
     ListNode* reverseList(ListNode* head) {
         // 和双指针法初始化是一样的逻辑
         // ListNode* cur = head;
         // ListNode* pre = NULL;
         return reverse(NULL, head);
     }
 
 };

时间复杂度: O(n), 要递归处理链表的每个节点
空间复杂度: O(n), 递归调用了 n 层栈空间

我们可以发现，上面的递归写法和双指针法实质上都是从前往后翻转指针指向，其实还有另外一种与双指针法不同思路的递归写法：从后往前翻转指针指向。

具体代码如下（带详细注释）：

 class Solution {
 public:
     ListNode* reverseList(ListNode* head) {
         // 边缘条件判断
         if(head == NULL) return NULL;
         if (head->next == NULL) return head;
         
         // 递归调用，翻转第二个节点开始往后的链表
         ListNode *last = reverseList(head->next);
         // 翻转头节点与第二个节点的指向
         head->next->next = head;
         // 此时的 head 节点为尾节点，next 需要指向 NULL
         head->next = NULL;
         return last;
     }
 };

时间复杂度: O(n)
空间复杂度: O(n)

自律先锋

关注

27
点赞
踩
24

收藏

觉得还不错? 一键收藏
0
评论
Day3-链表_基础内容

关键是初始化的地方，可能有的同学会不理解，可以看到双指针法中初始化 cur = head，pre = NULL，在递归法中可以从如下代码看出初始化的逻辑也是一样的，只不过写法变了。为什么要保存一下这个节点呢，因为接下来要改变 cur->next 的指向了，将cur->next 指向pre ，此时已经反转了第一个节点了。// 获取到第index个节点数值，如果index是非法数值直接返回-1，注意index是从0开始的，第0个节点就是头结点。// 将虚拟头结点指向head，这样方便后面做删除操作。
复制链接

扫一扫