代码随想录02：链表

一、链表理论基础

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个节点：
  • 双指针法
  • 力扣题目链接
• 链表相交：
  • 力扣题目链接
• 环形链表：
  • 双指针法
  • 力扣题目链接