leetcode-链表

链表是一个用指针串联起来的线性结构，每个结点由数据域和指针域构成，指针域存放的是指向下一个节点的指针，最后一个节点指向NULL，第一个结点称为头节点head。

常见的链表有单链表、双向链表、循环链表。双向链表就是多了一个pre指针，头节点的pre指向NULL。循环链表就是尾节点的next指向了头节点，可以用来解决约瑟夫问题。

链表内存为节点间不连续，节点内连续。适用于解决数据长度不固定，不经常查找，经常增删的问题。

要学会自己定义struct ListNode，并且要知道构造函数自己写完怎么用（使用ListNode *node = new ListNode(3)）这样就可以new一个ListNode出来让node指向了。

1.移除元素 Leetcode203. 分为虚拟节点和不使用虚拟节点

在这一题里我终于体会到了tmp=nullptr的用处。

代码随想录里明明只使用了delete tmp，但是我没有用tmp = nullptr 还是报了内存的错误，下面这样写才通过，但是看起来明明不对。

/**
 * 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) {
    // 2. 使用虚拟头节点
        while(head!=nullptr && head->val ==val)
        {
            ListNode* tmp = head;//内存~
            head = head->next;
            delete tmp;//内存~
        }

        ListNode* cur = head;
        while(cur != nullptr && cur->next != nullptr)
        {
            if(cur->next->val == val)
            {
                ListNode* tmp = cur->next;//~
                cur->next = cur->next->next;
                delete tmp;//~
            }
            else
                cur = cur->next;
        }
        return head;  
    }
};

/**
 * 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) {
    // 2. 使用虚拟头节点
        ListNode *dummynode = new ListNode();
        dummynode->next = head;
        ListNode *cur = dummynode;

        while(cur != nullptr && cur->next != nullptr)
        {
            if(cur->next->val == val)
            {
                ListNode* tmp = cur->next;//考虑一下内存，不考虑也没事，只是大一些
                cur->next = cur->next->next;
                delete tmp;//~同上
            }
            else
                cur = cur->next;
        }
        return dummynode->next;  
    }
};

这里要注意我的虚拟头节点也是一个指针类型的，因为我要使用到dummynode->next这种操作，仅仅是指向虚拟头结点的一个指针而已。我一开始用的是ListNode dummynode = new ListNode()，这是不对的。

[注意]通常情况下，在执行了 delete 操作之后，将指针置为 nullptr 是不必要的，因为你不应该在删除后继续使用已经释放的内存。这不是内存管理的原则之一。这里，delete之前要暂存一下删的东西地址，不然不知道删啥。

2.设计链表20230828

本题给了ListNode的节点定义，需要写MyLinkedList中的构造函数、get、addAtHead、addAtTail、addAtIndex、deleteAtIndex。

需要注意的是：第一，写错了什么东西--。我本来是index--，误写成tmp--，找了半天也没发现哪里错。

第二个写错的是这里：

这里写错了，其实index=0也可以删，就是把头节点删掉。这里错误导致我有三个用例不通过，都是delete头节点的。改成>=0就行了。

这一题熟悉了链表的操作，并且深刻体会了虚拟头节点的妙用。

3.反转链表LCR024 20230829

• 双指针法，清晰易懂：

/**
 * 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* reverseList(ListNode* head) {
        ListNode *pre = nullptr;
        ListNode *cur = head;
        while(cur){
            ListNode *tmp = cur -> next; 
            cur -> next = pre;
            pre = cur;
            cur = tmp;
        }
        return pre;
    }
};

代码真是超简单，但是记得我们本来只有prev和current，是因为要存断裂开来的current才引入了temp。

并且，记得prev最终指向尾节点，cur最终指向尾节点后的nullptr，所以while的条件是cur！=nullptr。当等于空，直接可以返回，返回的头节点就是prev。

时间复杂度O(n)，空间复杂度O(1)

class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        return reverse(nullptr,head);
    }
    ListNode* reverse(ListNode *pre, ListNode *cur){
        if(cur == nullptr)
            return pre;
        else
        {
            ListNode *temp = cur->next; 
            cur -> next = pre;
            return reverse(cur, temp);
        }
    }
};

以上是递归写法，是双指针法的变体。

4. 两两交换链表中的节点Leetcode24. 20230901

/**
 * 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* swapPairs(ListNode* head) {
        //定义虚拟头节点
        ListNode *dummynode = new ListNode();
        dummynode -> next = head;
        ListNode *cur = dummynode;
        while(cur -> next != nullptr && cur -> next -> next != nullptr)
        {
            ListNode *tmp = cur -> next;
            ListNode *tmp1 = cur -> next -> next -> next;
            cur -> next = cur -> next -> next;
            cur -> next -> next = tmp;
            tmp -> next = tmp1;
            cur = cur -> next -> next;
        }
        return dummynode -> next;
    }
};

这一题画图非常重要！

5. 删除链表的倒数第N个节点：删除某节点，指针需要跑到节点前面20230902

本题是快慢指针的经典使用！

/**
 * 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* removeNthFromEnd(ListNode* head, int n) {       
        ListNode *dummynode = new ListNode(); 
        dummynode->next = head;
        ListNode *fast = head;
        ListNode *slow = dummynode;

        while(n-- && fast != nullptr){
            fast = fast->next;
        }
        while(fast != nullptr){
            fast = fast->next;
            slow = slow->next;
        }
        ListNode *tmp = slow->next;
        slow->next = slow->next->next;
        delete tmp;
        return dummynode->next;
    }
};

时间复杂度：O(n)，空间复杂度：O(1)

6. 链表相交 面试题 02.07.  重点在于尾部对齐思想和非值相等20230902

尾部对齐这个没啥好说的，跟上题快慢指针一样思想记住就行

非值相等……简单来说就是我做题的时候以为下面这个示例应该1的时候就是相交的，其实测试用例应该是真给了两个相交链表，导致值相等的时候不一定相交，反而是直接判断指针curA!= curB相等才对。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        // 尾部对齐
        int lengthA = 0, lengthB = 0;
        ListNode *curA = headA, *curB = headB;
        while (headA != nullptr){
            headA = headA->next;
            lengthA++;
        }
        while (headB != nullptr){
            headB = headB->next;
            lengthB++;
        }
        if(lengthA > lengthB){
            int tmp = lengthA - lengthB;
            while(tmp--){
                curA = curA->next;
            } 
        }
        else{
            int tmp = lengthB - lengthA;
            while(tmp--){
                curB = curB->next;
            } 
        }
        // 移动指针找交点
        while(curA != nullptr && curA!= curB)//本来写的是curA->val != curB->val
        {
            curA = curA->next;
            curB = curB->next;
        }
        return curA;
    }
};

7. 环形链表II Leetcode142. 20230903

本题主要是数学证明居多。

这一题是这两篇唯一让我觉得有些心虚的，因为这个数学证明我自己肯定不会去想出来，让我们来看一下本题的思路：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
        ListNode *fast = head;
        ListNode *slow = head;
        while(fast != nullptr  && fast->next !=nullptr){
            fast = fast->next ->next;
            slow = slow->next;
            if(fast == slow){
                ListNode *index1 = fast;
                ListNode *index2 = head;
                while(index1 != index2){
                    index1 = index1->next;
                    index2 = index2->next;
                }
                return index1;
            }
        }
        return nullptr;
    }
};

首先是快慢双指针从头开始，快指针到空就肯定无环；然后快指针两倍速入环，慢指针跟着一倍速入，慢指针走不到一圈必被快指针追上（考虑最坏情形，慢指针刚入，快指针刚比他快一格；当慢指针走完1环，快指针肯定走完2环。所以，慢在走1环的中途肯定被追上。）

我们列出的数学式子是2(x+y)=x+y+n(y+z)，注意这个2，就是因为快指针两格两格跨，又跟慢指针同时触发，所以是走了慢指针两倍距离。然后可以看到x=(n-1)(y+z)+y

那么如果我们要求入环点，就是求这个x。考虑被追上的这个情形下，正好有了y的尾部，那么走x与从y走最终就会在y头部相遇，这个从刚刚的式子可以几何理解，不论多走几圈，最终都是在y头部相遇，那么就得到了最后的点。[对于这一段真的是有点心虚，自己推不出来，笨笨again]

链表到此就结束了，说谢谢随想录。

8. 两数相加 leetcode2. 20231025

时隔一个月，在leetcode题单上看到这个第二题，是之前被我看过、提交过、放弃过的题，就在学会链表之后自己尝试了一下，调试了很多遍，好在最后通过了。但是，我并不知道这一题dummynode有什么用，也忘记了怎么写，并且忘记了如何优雅地循环新增node，所以只能抱着“节省空间”的想法，基于一个链表去进行求和，写出了如下丑陋冗余的代码：

/**
 * 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* addTwoNumbers(ListNode* l1, ListNode* l2) {
        ListNode *node = l2;
        ListNode *result = l2;
        bool carry = 0;
        while(l1 != nullptr && l2 != nullptr){
            int temp = l1->val + l2->val + carry;
            carry = 0;
            l1 = l1->next;
            l2 = l2->next;
            if(temp > 9){
                carry = 1;
            }
            node->val = temp % 10;
            if(l2 != nullptr)
                node = node->next;
        }
        
        if(l1 == nullptr && l2 == nullptr && carry == 1){
            ListNode *tailnode = new ListNode();
            tailnode->val = 1;
            node->next = tailnode;             
        }
            
        while(l1 != nullptr){
            node -> next = l1;
            node = node->next;
            int temp = l1->val + carry;
            carry = 0;
            l1 = l1->next;
            if(temp > 9){
                carry = 1;
            }
            node->val = temp % 10;
            if(l1 == nullptr && carry == 1){
                ListNode *tailnode = new ListNode();
                tailnode->val = 1;
                node->next = tailnode;             
            }
        }

        while(l2 != nullptr){
            int temp = l2->val + carry;
            carry = 0;
            l2 = l2->next;
            if(temp > 9){
                carry = 1;
            }
            node->val = temp % 10;
            if(l2 == nullptr && carry == 1){
                ListNode *tailnode = new ListNode();
                tailnode->val = 1;
                node->next = tailnode;             
            }
            node = node->next;
        }

        return result; 
    }

};

后来，看到了官方题解。

官方题解中，使用了

int n1 = l1 ? l1->val: 0;

也就是说，l1=nullptr的时候，自动就是0值，可以直接用；

然后，又用了

if (!head) {
head = tail = new ListNode(sum % 10);
} else {
tail->next = new ListNode(sum % 10);
tail = tail->next;
}

意思是说，tail往后增长是直接用next去new一个，这样的话就可以实现我想实现的循环新增；

然后，如何让两个链表一起停止呢？只要对l1和l2分别判断是不是为空，如果为空就不next，反之继续next