链表篇（启+一）（基础介绍+刷题分析）

链表基础

———— 《代码随想录感悟》

链表类型

1. 链表定义

   链表是一种通过指针串联在一起的线性结构，每一个节点由两部分组成，一个是数据域一个是指针域（存放指向下一个节点的指针），最后一个节点的指针域指向null（空指针的意思）

   链接的入口节点称为链表的头结点也就是head

2. 单链表：

   该表中的节点只能指向节点的下一个节点

3. 双链表：

   每一个节点有两个指针域，一个指向下一个节点，一个指向上一个节点。因此既可以向前查询也可以向后查询。
   

4. 循环链表

​ 即链表首尾相连——可以用来解决约瑟夫环问题

链表存储方式

1. 与数组的不同

   数组在内存中是连续分布的，链表在内存是离散的

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

   各个节点分布在内存中多个不同地址空间上，通过指针串联在一起。

链表的定义

• 手写链表——定义节点

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

• 在C++中，可以不定义构造函数，但由C++默认生成的构造函数不会初始化任何成员变量——即初始化时不能直接给变量赋值。

• 两种初始化节点的方式

  • ListNode* head = new ListNode(5);
    

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

链表的操作

删除节点

1. 图解：

   

   即将C节点的next指针指向E节点，最好之后手动释放D节点，释放这块内存（专指C++）

添加节点

即将C节点的next指针指向添加的F指针，F的next指针指向D指针

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

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

性能分析

链表篇（一）——移除链表元素

203. 移除链表元素

自己题解

分析题意，即筛选删除所选定的元素，此处有两种情况，

• 当val就是头指针时，即将头指针赋成下一个元素即可，
• 当val是除头指针的其他元素，那就按照常规的循环加判断即可。

代码：

/**
 * 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* removeElements(ListNode* head, int val) {
        while (head != NULL && head->val == val){
            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 = tmp->next;
                delete tmp;
            }
            else{
                cur = cur->next;
            }
        }
        return head;
    }
};

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

开拓2——递归法

由于链表有天然的递归性，因此，原链表亦可以看成是更短链表的组合[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xglo6JcQ-1647329469830)(C:\Users\lenovo\AppData\Roaming\Typora\typora-user-images\image-20220315150229929.png)]

如果头节点对应的数值不等于 val ，原问题的结果就是头节点后面挂接上子问题求得的紫色的链表，否则，结果就是子问题求得的紫色的链表

直接利用头节点的逐次递减来查找：实现代码的精简化：

class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {
       if(head == NULL) {
           return NULL;
       }
       
        head->next = removeElements(head->next,val);
        return head->val==val ? head->next : head;
    }
};

emoveElements(head->next,val);
return head->val==val ? head->next : head;
}
};