先说一嘴，链表头节点真的太好用了，就是这样： hhead->|0|head|->|a|b|->|c|d|->|e|nullptr|

203. 移除链表元素

给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == val 的节点，并返回 新的头节点 。

 

示例 1：

输入： head = [1,2,6,3,4,5,6], val = 6
输出： [1,2,3,4,5]

示例 2：

输入： head = [], val = 1
输出： []

// 方法1：分两次删除 头结点删除 非头结点删除
class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {
        // ListNode *lic = head;
        while (head != nullptr && head->val == val) {
            ListNode *tmp = head; //
            head = head->next;
            delete tmp; // 为了要把节点删除
        } // 可以确定第一个元素不等于val
        ListNode *lic = head;
        while (lic != nullptr && lic->next != nullptr) {    
            if (lic->next->val == val) {
                ListNode *tmp2 = lic->next; //
                lic->next = lic->next->next;//lic->|val|next|->|x|next|->|val|next|
                delete tmp2; // 为了要把节点删除
            } else {
                lic = lic->next;
            } 
        }
        // while (lic != nullptr) { //这个为什么不对呢，艹
        //     if (lic->val == val) {
        //         ListNode *tmp2 = lic; //
        //         lic = lic->next; //lic->|val|next|->|x|next|->|val|next|
        //         delete tmp2; // 为了要把节点删除
        //     } else {
        //         lic = lic->next;
        //     } 
        // }
        return head;
    }
};

头结点也太好用了，下面的题基本上都设置了头结点

// 方法2：设置头头节点删除 hhd->|0|head|->|val|next|->|x|next|->|val|next|
class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {
        ListNode* hhd = new ListNode(0); // hhd这个指针指向的是一个struct ListNode类
        hhd->next = head;
        while () {
            ListNode* mov = head;
            if (mov)
        }
        return head;
    }
};

707.设计链表

你可以选择使用单链表或者双链表，设计并实现自己的链表。

单链表中的节点应该具备两个属性：val 和 next 。val 是当前节点的值，next 是指向下一个节点的指针/引用。

如果是双向链表，则还需要属性 prev 以指示链表中的上一个节点。假设链表中的所有节点下标从 0 开始。

实现 MyLinkedList 类：

• MyLinkedList() 初始化 MyLinkedList 对象。
• int get(int index) 获取链表中下标为 index 的节点的值。如果下标无效，则返回 -1 。
• void addAtHead(int val) 将一个值为 val 的节点插入到链表中第一个元素之前。在插入完成后，新节点会成为链表的第一个节点。
• void addAtTail(int val) 将一个值为 val 的节点追加到链表中作为链表的最后一个元素。
• void addAtIndex(int index, int val) 将一个值为 val 的节点插入到链表中下标为 index 的节点之前。如果 index 等于链表的长度，那么该节点会被追加到链表的末尾。如果 index 比长度更大，该节点将 不会插入 到链表中。
• void deleteAtIndex(int index) 如果下标有效，则删除链表中下标为 index 的节点。

示例：

输入
["MyLinkedList", "addAtHead", "addAtTail", "addAtIndex", "get", "deleteAtIndex", "get"]
[[], [1], [3], [1, 2], [1], [1], [1]]
输出
[null, null, null, null, 2, null, 3]

解释
MyLinkedList myLinkedList = new MyLinkedList();
myLinkedList.addAtHead(1);
myLinkedList.addAtTail(3);
myLinkedList.addAtIndex(1, 2);    // 链表变为 1->2->3
myLinkedList.get(1);              // 返回 2
myLinkedList.deleteAtIndex(1);    // 现在，链表变为 1->3
myLinkedList.get(1);              // 返回 3

这个题其实只要细心一点就能做出来，还有就是用了头结点

class MyLinkedList {
public:
    struct MyListNode{
        int val;
        MyListNode* next;
        MyListNode(int val) : val(val), next(nullptr) {};
    };

    MyLinkedList() {
        _hdListNode = new MyListNode(0); // _hdListNode->|0|nullptr| 
                                        // 带头结点的链表，数据结构讲过
        _lSize = 0;
    }
    
    int get(int index) {//_hdListNode->|0|newnode|->|e|z|->|x|y|->|a|b|->|c|jnullptr| 4
        if (index < _lSize && index >= 0) {
            MyListNode* hdtmp = _hdListNode;
            for (int i = 0; i < index; i++) { //错误2，写成了for (int i = 0; i < _lSize; i++)
                hdtmp = hdtmp->next;
            }
            return hdtmp->next->val;
        } else {
            return -1;
        }
    }
    
    void addAtHead(int val) { // 错误1 ：一开始忘了链表的头结点结构，现在看起来，头结点也太香了
        // _hdListNode->|0|z|->|x|y| 链表有头结点就是香
        MyListNode* newnode = new MyListNode(val); // newnode->|val|nullptr|
        newnode->next = _hdListNode->next; // newnode->|val|z|
        _hdListNode->next = newnode; // _hdListNode->|0|newnode|->|val|z|->|x|y|
        _lSize++;
    }
    
    void addAtTail(int val) {
        MyListNode* hdtmp = _hdListNode;
        for (int i = 0; i < _lSize; i++) {
            hdtmp = hdtmp->next;
        }
        MyListNode* newnode = new MyListNode(val);
        hdtmp->next = newnode;
        _lSize++;
    }
    
    void addAtIndex(int index, int val) {
        MyListNode* hdtmp = _hdListNode;
        // _hdListNode->|0|newnode|->|e|z|->|x|y|->|a|b|->|c|jnullptr| 4
        if (index < _lSize) { 
            for (int i = 0; i < index; i++) { 
                hdtmp = hdtmp->next;
            } // hdtmp=z; index=2 
            // _hdListNode->|0|newnode|->|e|hdtmp|->|x|y| -v> 2|a|b|->|c|jnullptr| 4
            // 头结点，若想操作|a|b|，如删除或添加，应该拿到|e|z|，即hdtmp=z，前两格
            MyListNode* newnode = new MyListNode(val);
            newnode->next = hdtmp->next; // newnode->|val|y|
            hdtmp->next = newnode;
            _lSize++;
        } else if (index == _lSize) {
            addAtTail(val);
        }
    }
    
    void deleteAtIndex(int index) {
        // _hdListNode->|0|newnode|->|e|z|->|x|y|->|a|b|->|c|jnullptr| 4
        if (index < _lSize) {
            MyListNode* hdtmp = _hdListNode;
            for (int i = 0; i < index; i++) {
                hdtmp = hdtmp->next;
            } // hdtmp == z; index == 2; 删除|a|b|
            MyListNode* deltmp = hdtmp->next; //|e|hdtmp|->|x|y|->|a|b|; deltmp=y
            hdtmp->next = hdtmp->next->next; //|e|hdtmp|->|x|b|->|c|jnullptr|
            delete deltmp;
            _lSize--;
        }
    }

private:
    int _lSize;
    MyListNode* _hdListNode;        
};

/**
 * Your MyLinkedList object will be instantiated and called as such:
 * MyLinkedList* obj = new MyLinkedList();
 * int param_1 = obj->get(index);
 * obj->addAtHead(val);
 * obj->addAtTail(val);
 * obj->addAtIndex(index,val);
 * obj->deleteAtIndex(index);
 */

206. 反转链表

给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。

 

示例 1：

输入： head = [1,2,3,4,5]
输出： [5,4,3,2,1]

示例 2：

输入： head = [1,2]
输出： [2,1]

示例 3：

输入： head = []
输出： []

这是一个双指针法

class Solution { // 还是没有很懂
public:
    ListNode* reverseList(ListNode* head) { //题目里面给的都是不带头结点的
        ListNode* fastp = head;
        ListNode* slowp = nullptr;
        ListNode* temp;
        while (fastp) {
            temp = fastp->next; // temp向前走一格，这个最好还是放到循坏的开头，放到循环末尾会溢出
            fastp->next = slowp; // 交换
            slowp = fastp; // slowp向前走一格
            fastp = temp; // fast向前走一格
        } //我觉得这个妙处就在于处理好了开始的nullptr
        return slowp;
    }
};

24. 两两交换链表中的节点

给你一个链表，两两交换其中相邻的节点，并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题（即，只能进行节点交换）。

 

示例 1：

输入： head = [1,2,3,4]
输出： [2,1,4,3]

很强大

// fuck me 默写了一遍，翻转链表的加强版
// 就是说，节点的指向变换，值不变，要用虚拟头结点
class Solution { 
public:
    ListNode* swapPairs(ListNode* head) {
        
        ListNode* fakehead = new ListNode(0);
        fakehead->next = head; // 相当于重新创了一个节点 之前的head不要了
        ListNode* cur = fakehead;

        while (cur->next != nullptr && cur->next->next != nullptr) { // 错误2 这个范围不会写
            ListNode* tmp = cur->next;
            ListNode* tmp2 = cur->next->next->next;
            
            cur->next = cur->next->next;
            cur->next->next = tmp;
            cur->next->next->next = tmp2;

            cur = cur->next->next; // 错误1，要有头结点，所以说next两次，不是三次
        }
        return fakehead->next;
    }
};

19. 删除链表的倒数第 N 个结点

给你一个链表，删除链表的倒数第 n **个结点，并且返回链表的头结点。

 

示例 1：

输入： head = [1,2,3,4,5], n = 2
输出： [1,2,3,5]

示例 2：

输入： head = [1], n = 1
输出： []

示例 3：

输入： head = [1,2], n = 1
输出： [1]

class Solution { // 不考虑删除不了吧，就是鲁棒性
public: // 自己的方法
    ListNode* removeNthFromEnd(ListNode* head, int n) {

        ListNode* fastp = head;
        int numb = 1;
        while (fastp->next != nullptr) {
            fastp = fastp->next;
            numb ++;
        }

        ListNode* dummyHead = new ListNode(0);
        dummyHead->next = head;
        ListNode* slowp = dummyHead;
        for (int i = 0; i < numb - n; i++) {
            slowp = slowp->next;
        }

        ListNode* tmp = slowp->next;
        slowp->next = slowp->next->next;
        delete tmp;
        return dummyHead->next;
        
    }
};

方法2：

class Solution { // 艹，明明一开始想到用双指针的，快指针先走几步
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        
        ListNode* dummyHead = new ListNode(0);
        dummyHead->next = head;
        ListNode* fastp = dummyHead;
        ListNode* slowp = dummyHead;

        for (int i = 0; i < n; i++) { //循环n次，背过
            fastp = fastp->next;
        }

        while (fastp->next != nullptr) {
            fastp = fastp->next;
            slowp = slowp->next;
        }

        ListNode* tmp = slowp->next;
        slowp->next = slowp->next->next;
        delete tmp;
        return dummyHead->next;
        
    }
};

142. 环形链表 II

这个难，难在找环的入口，而且找入口的方法还是不是很会

给定一个链表的头节点  head ，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。

如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。如果 pos 是 -1，则在该链表中没有环。注意：pos 不作为参数进行传递，仅仅是为了标识链表的实际情况。

不允许修改 链表。

示例 1：

输入： head = [3,2,0,-4], pos = 1
输出： 返回索引为 1 的链表节点
解释： 链表中有一个环，其尾部连接到第二个节点。

示例 2：

输入： head = [1,2], pos = 0
输出： 返回索引为 0 的链表节点
解释： 链表中有一个环，其尾部连接到第一个节点。

//fastp指针每次移动两个节点，slowp指针每次移动一个节点，
//如果 fastp 和 slowp指针在途中相遇 ，说明这个链表有环
class Solution { //超出时间限制 fuck
public:
    ListNode *detectCycle(ListNode *head) { //要么有环 要么没环 有环一定是在尾巴处
        ListNode* slowp = head;
        ListNode* fastp = head;
        //是否有环
        // while (fastp->next != nullptr && fastp->next->next != nullptr) {
        while (fastp != nullptr && fastp->next != nullptr) {
            slowp = slowp->next;
            fastp = fastp->next->next;
            
            if (fastp == slowp) { // 有环，找入口
                ListNode* fastNewp = slowp;
                ListNode* slowNewp = head;
                while (fastNewp != slowNewp) {
                    // fastNewp = fastNewp->next->next;
                    fastNewp = fastNewp->next;
                    slowNewp = slowNewp->next;
                }
                return fastNewp;
            }
        }
        return nullptr;
    }
};