【笔记】链表

本系列总计六篇文章，是 基于STL实现的笔试题常考七大基本数据结构 该文章在《代码随想录》和《labuladong的算法笔记》题目中的具体实践，每篇的布局是这样的：开头是该数据结构的总结，然后是在不同场景的应用，以及不同的算法技巧。本文是系列第二篇，介绍了链表的相关题目，重点是要掌握快慢、左右双指针算法，以及涉及插入、删除时，为了统一操作逻辑，要引入虚拟头节点。

下面文章是在《代码随想录》和《labuladong的算法笔记》题目中的具体实践：
【笔记】数组
【笔记】链表
【笔记】哈希表
【笔记】字符串
【笔记】栈与队列
【笔记】二叉树

0、总结

• 双指针，同步双指针，左右双指针，快慢双指针
• 虚拟头节点：凡是涉及对链表的插入、删除擦操作，均需要构建虚拟头节点，不然需要单独写处理头节点的逻辑。修改和查询不需要。设立虚拟节点还可以在开头省略对于链表头是否为空的判断。

1、不需要双指针

203. 移除链表元素 - 力扣（LeetCode）

思路：设立虚拟头节点，但应返回真实的头节点。最好手动delete被删除的节点，而不是仅仅改变指针。仅使用额外的一个指针cur即可解决。

注意：代码逻辑中有cur->next->next，那么while中必须判断cur->next不为空

class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {
        ListNode* dummyHead = new ListNode(-1, head);
        ListNode* cur = dummyHead;
        while (cur->next != nullptr) {
            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、双指针法

707. 设计链表 - 力扣（LeetCode）

这题debug到心力交瘁…

思路：此题包含了所有增删改查操作，参数有index的需要先判断index合理性

• 获取第index节点数值，cur不需要指向dummyHead，直接指向第一个真实节点
• 头插法，不需要cur
• 尾插法，cur初始化指向dummyHead
• 在index位置插入，cur初始化指向dummyHead
• 删除index节点，cur初始化指向dummyHead

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，则置为0，作为链表的新头节点。
    void addAtIndex(int index, int 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++;
    }

    // 删除第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;
        _size--;
    }

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

206. 反转链表 - 力扣（LeetCode）

迭代法思路：利用双指针cur，pre，循环中再来个next记录下一个位置，四行代码解决

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

递归法思路：把第一个节点看作head，剩下所有节点的集合看作node，每次只考虑这两个节点的翻转

class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        if (head == NULL || head->next == NULL) {
            return head;
        }
        // 递归调用，当前节点后面所有节点已翻转好，它们的集合是node
        ListNode* node = reverseList(head->next);
        // 现在只考虑当下head、node两个节点的反转
        head->next->next = head;
        head->next = NULL;
        return node;
    }
};

24. 两两交换链表中的节点 - 力扣（LeetCode）

思路：利用双指针，进行模拟，每次操作以下三个步骤

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-VkOoDSyh-1670557984720)(https://code-thinking.cdn.bcebos.com/pics/24.%E4%B8%A4%E4%B8%A4%E4%BA%A4%E6%8D%A2%E9%93%BE%E8%A1%A8%E4%B8%AD%E7%9A%84%E8%8A%82%E7%82%B91.png)]

class Solution {
public:
    ListNode* swapPairs(ListNode* head) {
        if (head == nullptr || head->next == nullptr) return head;
        ListNode* dummyHead = new ListNode(-1, head);
        ListNode* cur = dummyHead;
        // 将要翻转的两个位置不能为空
        while (cur->next != nullptr && cur->next->next != nullptr) {
            // 保存位置
            ListNode* tmp1 = cur->next;
            ListNode* tmp2 = cur->next->next->next;
            cur->next = cur->next->next; // 步骤1
            cur->next->next = tmp1; // 步骤2
            cur->next->next->next = tmp2; // 步骤3
            cur = cur->next->next;
        }
        return dummyHead->next;
    }
};

25. K 个一组翻转链表 - 力扣（LeetCode）

思路：206题从头到尾翻转，24题每两个一组翻转，很自然地过渡到 k 个一组翻转。综合了迭代和递归思想的好题。

三步走

1、先反转以 head 开头的 k 个元素。

2、将第 k + 1 个元素作为 head 递归调用 reverseKGroup 函数。

3、将上述两个过程的结果连接起来。

reverse()函数参考自反转链表的迭代版本，改成区间[a，b)的翻转。206题是从头到尾翻转，即翻转head到null区间内的链表。

reverseKGroup()函数参考自迭代版本，每k个一组翻转并拼接，不足k个不反转

class Solution {
public:
    // 1、先反转以 head 开头的 k 个元素。
    // 2、将第 k + 1 个元素作为 head 递归调用 reverseKGroup 函数。
    // 3、将上述两个过程的结果连接起来。
    // 迭代反转链表，区间版本，原题目版本是head到null
    ListNode* reverse(ListNode* a, ListNode* b) {
        ListNode* pre = nullptr;
        ListNode* cur = a;
        while (cur != b) {
            ListNode* tmp = cur->next;
            cur->next = pre;
            pre = cur;
            cur = tmp;
        }
        return pre;
    }

    ListNode* reverseKGroup(ListNode* head, int k) {
        if (head == nullptr) return nullptr;
        // 区间 [a, b) 包含 k 个待反转元素
        ListNode* a = head;
        ListNode* b = head;
        // 不能用while(k--)，会改变 k 值，导致只能反转前k个节点
        for (int i = 0; i < k; ++i) {
            // 不足 k 个不需反转
            if (b == nullptr) return head;
            b = b->next;
        }
        // 反转前 k 个元素
        ListNode* newHead = reverse(a, b);
        // 递归反转后续链表并连接起来
        a->next = reverseKGroup(b, k);
        return newHead;
    }
};

19. 删除链表的倒数第 N 个结点 - 力扣（LeetCode）

思路：快慢双指针，快指针先走 k 步，然后快慢指针一起走。快指针走到尾节点的时候，慢指针刚好指向要删除的指针的前一个节点。直接进行删除，记得手动delete

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

面试题 02.07. 链表相交 - 力扣（LeetCode）

思路：双指针，每个指针遍历 A+B 长度，则交点必然出现在 A+B 长度遍历结束前。

class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        ListNode* pa = headA;
        ListNode* pb = headB;
        while (pa != pb) {
            // 不空继续向后遍历，若空遍历另一链表，若有交点一定在A+B内相遇
            pa = pa != NULL ? pa->next : headB;
            pb = pb != NULL ? pb->next : headA;
        }
        return pa;
    }
};

142. 环形链表 II - 力扣（LeetCode）

思路：双指针的快慢指针法，首先，若有环快慢指针必定环中相遇，其次，从相遇点和头节点出发的指针必定在入口相遇

注意：快指针需要判断，while的判断是 fast及其下一跳 均不空

class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
        ListNode* fast = head;
        ListNode* slow = head;
        // 若有环必定环中相遇，从相遇点和头出发的指针必定在入口相遇
        // 一次走两步的指针需要双条件判断
        while (fast != NULL && fast->next != NULL) {
            fast = fast->next->next;
            slow = slow->next;
            if (fast == slow) {
                ListNode* entry = head;
                while (entry != slow) {
                    entry = entry->next;
                    slow = slow->next;
                }
                return entry;
            }
        }
        return NULL;
    }
};