代码随想录02：链表
文章目录
- 一、链表理论基础
-
- 1、链表的类型
- 2、链表的存储方式
- 3、链表的定义
- 4、链表的操作
-
- 4.1、删除节点
- 4.2、添加节点
- 5、性能分析
- 二、移除链表元素
-
- 1、使用原来的链表来进行删除操作
- 2、设置一个虚拟头结点在进行删除操作
- 三、设计链表（链表常用操作）
- 四、翻转链表
-
- 1、双指针法
- 2、递归法
- 五、两两交换链表中的节点
- 六、删除链表的倒数第N个节点
- 七、链表相交
- 八、环形链表II
- 九、总结
一、链表理论基础
1、链表的类型
（1）单链表
什么是链表，链表是一种通过指针串联在一起的线性结构，每一个节点由两部分组成，一个是数据域一个是指针域（存放指向下一个节点的指针），最后一个节点的指针域指向null（空指针的意思）。
链接的入口节点称为链表的头结点也就是head。
（2）双链表
（3）循环链表
2、链表的存储方式
数组是在内存中是连续分布的，但是链表在内存中可不是连续分布的。
3、链表的定义
单链表的定义：
// 单链表
struct ListNode {
int val; // 节点上存储的元素
ListNode *next; // 指向下一个节点的指针
ListNode(int x) : val(x), next(NULL) {} // 节点的构造函数
};
这时候就会产生疑惑
Q：ListNode中第三行的构造函数不定义可以吗？是做什么的？
A：不必要，C++默认生成一个构造函数
但加上构造函数有好处，如初始化节点时：
-
采用构造函数的方法：
ListNode* head = new ListNode(5); -
采用C++默认的构造函数：
ListNode* head = new ListNode(); head->val = 5;
4、链表的操作
4.1、删除节点
注意：
-
C++里需手动释放删除的节点的内存。
-
其他语言例如Java、Python，有自己的内存回收机制，不用自己手动释放。
4.2、添加节点
5、性能分析
二、移除链表元素
操作链表的两个方法：
直接使用原来的链表来进行操作。
设置一个虚拟头结点在进行操作。
之后我们移除链表元素也是基于上述两个方法展开。
以一下LeetCode例题为例：
-
题目：力扣题目链接
-
文档：代码随想录 (programmercarl.com)
-
视频解析：链表基础操作| LeetCode：203.移除链表元素
题意：删除链表中等于给定值 val 的所有节点。
示例 1：
输入：head = [1,2,6,3,4,5,6], val = 6
输出：[1,2,3,4,5]
示例 2：
输入：head = [], val = 1
输出：[]
示例 3：
输入：head = [7,7,7,7], val = 7
输出：[]
1、使用原来的链表来进行删除操作
首先我们需要判断头节点是否为目标整数，是则删除，如何删除节点：
-
删除链表的其他节点：通过前一个节点来移除当前节点，而头结点没有前一个节点。
-
删除头节点：将头结点向后移动一位。
写代码的时候也会发现，需要单独写一段逻辑来处理移除头结点的情况。
class Solution {
public:
ListNode* removeElements(ListNode* head, int val) {
/*
删除头节点：
- 判断头节点是否为目标整数;
- 注意这里为while而非if，因为你删了当前的头节点，还有新的头节点,循环删除至头节点非目标整数，则退出循环
*/
while(head != NULL && head->val == val){
ListNode* tmp = head;
head = head->next;
delete tmp;
}
// 删除非头节点：
ListNode* cur = head; // head为真实的头节点，cur为我们在循环过程中...
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; // 最终返回链表的头节点
}
};
2、设置一个虚拟头结点在进行删除操作
P：单独写一段逻辑来处理移除头结点太麻烦，可不可以 以一种统一的逻辑来移除 链表的节点？
A：设置一个虚拟头结点，这样原链表的所有节点就都可以按照统一的方式进行移除了
class Solution {
public:
ListNode* removeElements(ListNode* head, int val) {
// 设置虚拟头节点
ListNode* dummyHead = new ListNode(0);
dummyHead->next = head;
ListNode* cur = dummyHead;
while(cur->next != NULL){
if(cur->next->val == val){
ListNode* temp = cur->next;
cur->next = cur->next->next;
delete temp;
}
else{
cur = cur->next;
}
}
head = dummyHead->next;
delete dummyHead;
return head;
}
};
三、设计链表（链表常用操作）
以下面这道LeetCode题目为切入点：
- 题目：707. 设计链表 - 力扣（LeetCode）
题意：
在链表类中实现这些功能：
- get(index)：获取链表中第 index 个节点的值。如果索引无效，则返回-1。
- addAtHead(val)：在链表的第一个元素之前添加一个值为 val 的节点。插入后，新节点将成为链表的第一个节点。
- addAtTail(val)：将值为 val 的节点追加到链表的最后一个元素。
- addAtIndex(index,val)：在链表中的第 index 个节点之前添加值为 val 的节点。如果 index 等于链表的长度，则该节点将附加到链表的末尾。如果 index 大于链表长度，则不会插入节点。如果index小于0，则在头部插入节点。
- deleteAtIndex(index)：如果索引 index 有效，则删除链表中的第 index 个节点。
示例：
MyLinkedList linkedList = new MyLinkedList();
linkedList.addAtHead(1);
linkedList.addAtTail(3);
linkedList.addAtIndex(1,2); //链表变为1-> 2-> 3
linkedList.get(1); //返回2
linkedList.deleteAtIndex(1); //现在链表是1-> 3
linkedList.get(1); //返回3
上代码：
class MyLinkedList {
public:
struct LinkedNode
{
int val;
LinkedNode* next;
LinkedNode(int val):val(val),next(nullptr){}
};
MyLinkedList() {
// 定义虚拟头节点
_dummyHead = new LinkedNode(0);
_size = 0;
}
int get(int index) {
// 若 index 为非法值，则返回 -1
if(index >= _size || index < 0 ){
return -1;
}
LinkedNode* cur = _dummyHead->next;
while(index--){
cur = cur->next;
}
return cur->val;
}
void addAtHead(int val) {
LinkedNode* newHead = new LinkedNode(val);
newHead->next = _dummyHead->next;
_dummyHead->next = newHead;
_size++;
}
void addAtTail(int val) {
LinkedNode* newNode = new LinkedNode(val);
LinkedNode* cur = _dummyHead;
while(cur->next != nullptr){
cur = cur->next;
}
cur->next = newNode;
_size++;
}
void addAtIndex(int index, int val) {
// if(index >= _size){ // 应该写 > 而非 >=
// return;
// }
// if(index <= 0){ // 题目限定：index在 [1, 1000] 之内，所以无需专门处理
// addAtHead(val);
// }
if (index > _size || index < 0) {
return;
}
LinkedNode* newNode = new LinkedNode(val);
LinkedNode* cur = _dummyHead;
while(index--){
cur = cur->next;
}
newNode->next = cur->next;
cur->next = newNode;
_size++;
}
void deleteAtIndex(int index) {
if(index >= _size || index < 0 ){
return;
}
LinkedNode* cur = _dummyHead;
while(index--){
cur = cur->next;
}
LinkedNode* temp = cur->next;
cur->next = cur->next->next;
delete temp;
_size--;
}
void printLinkedList(){
LinkedNode* cur = _dummyHead;
while(cur->next != nullptr){
cout << cur->next->val << " ";
cur = cur->next;
}
cout << endl;
}
private:
int _size;
LinkedNode* _dummyHead;
};
四、翻转链表
题目：力扣题目链接(opens new window)
题意：反转一个单链表。
示例: 输入: 1->2->3->4->5->NULL 输出: 5->4->3->2->1->NULL
1、双指针法
动画效果：
代码：
class Solution {
public:
ListNode* reverseList(ListNode* head) {
ListNode* temp; // 保存cur的下一个节点
ListNode* cur = head;
ListNode* pre = NULL; // 起一个新链表
while(cur) // 遍历链表，直至链表为空
{
temp = cur->next; // 保存一下 cur的下一个节点
cur->next = pre; // 翻转操作（移动一个元素）
// 更新 pre 与 cur
pre = cur; // pre移动到新链表尾部（也就是cur刚引入的元素的那个位置）
cur = temp; // cur回到原链表位置，开始下一次循环
}
return pre;
}
};
2、递归法
代码：
class Solution {
public:
ListNode* reverse(ListNode* pre, ListNode* cur){
if(cur == NULL)
return pre;
ListNode* temp = cur->next; // 记录遍历老链表的位置
cur->next = pre; // 为新链表添加元素
return reverse(cur, temp); // 重复如此，直至老链表遍历完毕
}
ListNode* reverseList(ListNode* head) {
return reverse(NULL, head);
}
};
还有种方法：
上面的递归写法和双指针法实质上都是从前往后翻转指针指向，其实还有另外一种与双指针法不同思路的递归写法：从后往前翻转指针指向。
代码：
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;
}
};
五、两两交换链表中的节点
题目：力扣题目链接
题意：给定一个链表，两两交换其中相邻的节点，并返回交换后的链表。
示例:
输入：head = [1,2,3,4,5], n = 2 输出：[1,2,3,5]
简单来说就是重复以下三个步骤：
示例代码：
class Solution {
public:
ListNode* swapPairs(ListNode* head) {
ListNode* dummy_head = new ListNode(0);
dummy_head->next = head;
ListNode* cur = dummy_head;
// 循环终止条件：下一个节点为空 或者 只剩一个节点，不足以交换
while(cur->next != nullptr && cur->next->next != nullptr){
ListNode* temp = cur->next;
ListNode* temp1 = cur->next->next->next;
cur->next = cur->next->next; // 步骤一
cur->next->next = temp; // 步骤二
cur->next->next->next = temp1;
/*
加入“delete 临时节点”，会报错：
AddressSanitizer: heap-use-after-free 使用已释放内存
*/
// cout << temp << " ";
// delete temp;
// delete temp1;
cur = cur->next->next;
}
return dummy_head->next;
}
};
六、删除链表的倒数第N个节点
题目：19. 删除链表的倒数第 N 个结点 - 力扣（LeetCode）
题意：给你一个链表，删除链表的倒数第
n个结点，并且返回链表的头结点。示例:
输入：head = [1,2,3,4,5], n = 2 输出：[1,2,3,5]
目标：使用一趟扫描解决问题
方法：双指针法
示例代码：
class Solution {
public:
ListNode* removeNthFromEnd(ListNode* head, int n) {
ListNode* dummpy_head = new ListNode(0);
dummpy_head->next = head;
ListNode* fast = dummpy_head;
ListNode* slow = dummpy_head;
n += 1;
while(n-- && fast != NULL){
fast = fast->next;
}
while(fast != NULL){ // 注意是fast != NULL ，而非fast->next
fast = fast->next;
slow = slow->next;
}
slow->next = slow->next->next;
return dummpy_head->next;
}
};
七、链表相交
力扣链接：力扣题目链接
代码随想录：代码随想录 (programmercarl.com)
示例代码：
class Solution {
public:
ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
ListNode* curA = headA;
ListNode* curB = headB;
int lenA = 0, lenB = 0;
while (curA != NULL) { // 求链表A的长度
lenA++;
curA = curA->next;
}
while (curB != NULL) { // 求链表B的长度
lenB++;
curB = curB->next;
}
curA = headA;
curB = headB;
// 让curA为最长链表的头，lenA为其长度
if (lenB > lenA) {
swap (lenA, lenB);
swap (curA, curB);
}
// 求长度差
int gap = lenA - lenB;
// 让curA和curB在同一起点上（末尾位置对齐）
while (gap--) {
curA = curA->next;
}
// 遍历curA 和 curB，遇到相同则直接返回
while (curA != NULL) {
if (curA == curB) {
return curA;
}
curA = curA->next;
curB = curB->next;
}
return NULL;
}
};
八、环形链表II
LeetCode：力扣题目链接
代码随想录：代码随想录 (programmercarl.com)
解题思路：快慢指针法
- 判断链表是否环:
- 快指针一直移动，如果有环，fast可以一直移动，如果 fast == NULL || fast->next == NULL，则无环
- 如果有环，如何找到这个环的入口:
- fast 走两个节点，slow走一个节点，有环的话，一定会在环内相遇
- 从头结点出发一个指针，从相遇节点 也出发一个指针，这两个指针每次只走一个节点， 两个指针相遇的时候就是 环形入口的节点。
示例代码：
class Solution {
public:
ListNode *detectCycle(ListNode *head) {
ListNode* fast = head;
ListNode* slow = head;
while(fast != NULL && fast->next != NULL) { // 判断是否有环
slow = slow->next;
fast = fast->next->next;
// 快慢指针相遇，此时从head 和 相遇点，两个指针每次只走一个节点，同时查找直至相遇
if (slow == fast) {
ListNode* index1 = fast;
ListNode* index2 = head;
while (index1 != index2) {
index1 = index1->next;
index2 = index2->next;
}
return index2; // 返回环的入口
}
}
return NULL;
}
};
九、总结
1、链表理论基础
- 链表的种类主要为：单链表，双链表，循环链表
- 链表的存储方式：链表的节点在内存中是分散存储的，通过指针连在一起。
- 链表是如何进行增删改查的。
- 数组和链表在不同场景下的性能分析。
2、链表经典题目
- 虚拟头节点：
- 设置虚拟头节点
- 力扣题目链接
- 链表的基本操作
- 力扣题目链接
- 反转链表
- 双指针法/递归法
- 力扣题目链接
- 删除倒数第n个节点：
- 双指针法
- 力扣题目链接
- 链表相交：
- 力扣题目链接
- 环形链表：
- 双指针法
- 力扣题目链接