leetcode刷题记录——链表

leetcode刷题记录——链表

——参考代码随想录和力扣顺序刷题（https://programmercarl.com/）

总结：善用虚拟头节点（dummyHead)

---

文章目录

  141. 环形链表

  142. 环形链表 II

  203. 移除链表元素

  206. 反转链表

  21. 合并两个有序链表

  707. 设计链表

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

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

---

链表的定义

---

C/C++的定义链表节点方式，如下所示：

// 单链表
struct ListNode {
    int val;  // 节点上存储的元素
    ListNode *next;  // 指向下一个节点的指针
    ListNode(int x) : val(x), next(NULL) {}  // 节点的构造函数
    //leetcode定义如下:
    ListNode() : val(0), next(nullptr) {}
    ListNode(int x) : val(x), next(nullptr) {}
    ListNode(int x, ListNode *next) : val(x), next(next) {}
};

C++默认生成一个构造函数。

但是这个构造函数不会初始化任何成员变量，下面我来举两个例子：

通过自己定义构造函数初始化节点：

ListNode* head = new ListNode(5);

使用默认构造函数初始化节点：

ListNode* head = new ListNode();
head->val = 5;

所以如果不定义构造函数使用默认构造函数的话，在初始化的时候就不能直接给变量赋值！

---

链表的删除

---

删除操作记得要进行内存释放

ListNode *tmp = cur->next;
cur->next = cur->next->next;
delete tmp;

---

性能分析

---

141. 环形链表（简单）

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 的链表节点
解释：链表中有一个环，其尾部连接到第一个节点。

思路1：

• 哈希表

思路2：

• 快慢指针；

• 指针一快一慢同时出发，fastIndex走两格，slowIndex走一格；如果有环，一定会在环里面相遇（可以理解为快的在追慢的）；并且相遇时一定是slowIndex首次进入环，fashIndex已经在环内绕了n圈；并有以下条件：

  • fastIndex走的路程是slowIndex的两倍。

  • fastIndex - slowIndex的路程为n倍的环大小。

    • 为什么相遇时一定是slowIndex首次进入环：（临界条件：slowIndex和fastIndex同时同一个节点出发，当fastIndex走完一圈后，slowIndex在半圈，剩下的半圈走完后在起点一定会相遇）

    • 

    • 可以看出如果slow 和 fast同时在环入口开始走，一定会在环入口3相遇，slow走了一圈，fast走了两圈。重点来了，slow进环的时候，fast一定是在环的任意一个位置，如图：

    +

    • 那么fast指针走到环入口3的时候，已经走了k + n 个节点，slow相应的应该走了(k + n) / 2 个节点。

      因为k是小于n的（图中可以看出），所以(k + n) / 2 一定小于n。也就是说slow一定没有走到环入口3，而fast已经到环入口3了。

  • 作出一下假设（参考：作者：LeetCode-Solution 链接：https://leetcode.cn/problems/linked-list-cycle-ii/solution/huan-xing-lian-biao-ii-by-leetcode-solution/

  • 

  • （fast可能走了n圈，但slow一定在第一圈的途中）可以找到a = c+(n−1)(b+c) 的等量关系，我们会发现：从相遇点到入环点的距离加上 n-1圈的环长，恰好等于从链表头部到入环点的距离。

  • 因此找到相遇点后，从b开始往c方向一直走，和从a出发的指针相遇的地方，就是入环口。

• 图片参考：代码随想录__142-环形链表ii

• 

代码：

/**
 * 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) {
        if(head == nullptr || head -> next == nullptr) return nullptr;
        ListNode *fastIndex = head;
        ListNode *slowIndex = head;
        while(fastIndex != nullptr) {
            if(fastIndex->next == nullptr || slowIndex->next == nullptr) {、
                //双重判断：fastIndex != nullptr和fastIndex->next == nullptr；
                return nullptr;
            }
            //判断条件：fastIndex->next == nullptr 因为fastIndex->next->next放的是null（如果）因此判断fastIndex->next是否存在就行；
            fastIndex = fastIndex->next->next;
            slowIndex = slowIndex->next;
            if(slowIndex == fastIndex) {//如果放外面，第一个while的条件要改，影响第一次的情况和特殊条件下的情况：fastIndex != slowIndex || fastIndex == head;又可能fastIndex一直等于head（两个元素的环）；
                ListNode *temp = head;
                while(temp != fastIndex) {
                    fastIndex = fastIndex->next;
                    temp = temp->next;
                }
                return fastIndex;
            }
        }
        return nullptr;
    }
};

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/linked-list-cycle-ii
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

---

203. 移除链表元素（简单）

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

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

思路1：

• 从头遍历，遇到val相同就删除；

  • 删除代码：

  ListNode *tmp = cur->next;
  cur->next = cur->next->next;
  delete tmp;
  

• 遇到的问题：

  • 1、头节点怎么删除？
  • 2、出现报错：member access within null pointer of type ‘ListNode’（注意head != NULL）

• 解决1：

  • 方法两种；

    • 1、创建虚拟指针，指向头节点，然后可以整个进行遍历，最后再将虚拟指针->next赋值给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) {
            ListNode *vir = new ListNode(0,head);
            ListNode *cur = vir;
            while(cur->next != NULL) {
                    if(cur->next->val == val) {
                    ListNode *tmp = cur->next;
                    cur->next = cur->next->next;
                    delete tmp;
                }
                else {
                    cur = cur->next;
                }
            }
            head = vir->next;
            delete vir;
            return head;
        }
    };
    

    • 2、单独处理头节点；

    class Solution {
    public:
        ListNode* removeElements(ListNode* head, int val) {
            while(head != NULL && head->val == val) {
                ListNode *tmp = head;
                head = head->next;
                delete tmp;
            } 
            ListNode *cur = head;
            while(cur != NULL && cur->next != NULL) {
                if(cur->next->val == val) {
                    //这里是cur->next为什么不能cur->val == val：因为这样cur不会更新;
                    ListNode *tmp = cur->next;
                    cur->next = cur->next->next;
                    //这里更新的是cur->next;cur->next->val会更新;cur->val不会更新;
                    delete tmp;
                }
                else {
                    cur = cur->next;
                }
            }
            return head;
        }
    };
    

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/remove-linked-list-elements
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

---

206. 反转链表（简单）

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

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

思路：

• 用两个指针，分别指向front和behind再用一个temp指针，存behind->next；
• 双指针同步向前，双指针同步更新；

代码：

/**
 * 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 *tmp;
        ListNode *front = NULL;
        ListNode *behind = head;
        while(behind != NULL) {
            //相当于判断head是否为NULL;
            tmp = behind->next;
            behind->next = front;
            front = behind;
            behind = tmp;
        }
        return front;
    }
};

代码2：

• 思路和代码1相同，但是要对head进行处理
• head->next = NULL;
• 不然会报错；AddressSanitizer: heap-use-after-free on address 0x602000000078 at pc 0x00000037a94d bp 0x7ffc5a743860 sp 0x7ffc5a743858

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

---

21. 合并两个有序链表（简单）

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/merge-two-sorted-lists
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。

示例 1：
输入：l1 = [1,2,4], l2 = [1,3,4]
输出：[1,1,2,3,4,4]

思路1：

• 创建一个虚拟表头；然后从list1和list2中挑min（list1->val,list2->val）；假设list1->val较小，则虚拟表头指向list1（vir->next = list1）；然后虚拟表头（vir）更新为list1；更新list1（list1=list1->next）；

  • vir->next = list1;
    vir = list1;
    list1 = list1->next;
    

• 注意对最后一个节点进行处理；

  • if(list1==NULL) {
        vir->next = list2;
        break;
    }
    if(list2==NULL) {
        vir->next = list1;
        break;
    }
    

• 因为vir在不断更新，因此可以作为循环条件；

代码：

/**
 * 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* mergeTwoLists(ListNode* list1, ListNode* list2) {
        if(list1 == NULL || list2 == NULL) return list1 == NULL ? list2 : list1;
        ListNode *vir = new ListNode(0);
        ListNode *tmp = vir;
        while(vir!=NULL) {
            if(list1==NULL) {
                vir->next = list2;
                break;
            }
            if(list2==NULL) {
                vir->next = list1;
                break;
            }
            if(list1->val >= list2->val) {
                vir->next = list2;
                vir = list2;
                list2 = list2->next;
            }
            else {
                vir->next = list1;
                vir = list1;
                list1 = list1->next;
            }
        }
        ListNode *head = tmp->next;
        return head;
    }
};

• 复杂度分析

时间复杂度：O(n + m)，其中 n 和 m 分别为两个链表的长度。因为每次循环迭代中，l1 和 l2 只有一个元素会被放进合并链表中， 因此 while 循环的次数不会超过两个链表的长度之和。所有其他操作的时间复杂度都是常数级别的，因此总的时间复杂度为 O(n+m)。

• 空间复杂度：O(1)。我们只需要常数的空间存放若干变量

作者：LeetCode-Solution
链接：https://leetcode.cn/problems/merge-two-sorted-lists/solution/he-bing-liang-ge-you-xu-lian-biao-by-leetcode-solu/

思路2：

• 递归
• 每次判断选择list1还是list2；如果选择list1；则将list1->next传给下一次递归；
• 相当于每次判断都选择了一个节点；

代码：

class Solution {
public:
    ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
        if (l1 == NULL) {
            return l2;
        }
        if (l2 == NULL) {
            return l1;
        }
        if (l1->val <= l2->val) {
            l1->next = mergeTwoLists(l1->next, l2);
            return l1;
        }
        l2->next = mergeTwoLists(l1, l2->next);
        return l2;
    }
};

作者：z1m
链接：https://leetcode.cn/problems/merge-two-sorted-lists/solution/yi-kan-jiu-hui-yi-xie-jiu-fei-xiang-jie-di-gui-by-/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

---

707. 设计链表（中等）

在链表类中实现这些功能：

• get(index)：获取链表中第 index 个节点的值。如果索引无效，则返回-1。
• addAtHead(val)：在链表的第一个元素之前添加一个值为 val 的节点。插入后，新节点将成为链表的第一个节点。
• addAtTail(val)：将值为 val 的节点追加到链表的最后一个元素。
• addAtIndex(index,val)：在链表中的第 index 个节点之前添加值为 val 的节点。如果 index 等于链表的长度，则该节点将附加到链表的末尾。如果 index 大于链表长度，则不会插入节点。如果index小于0，则在头部插入节点。
• deleteAtIndex(index)：如果索引 index 有效，则删除链表中的第 index 个节点。

思路：

• 注意位置；index从0开始；
• 注意从虚拟节点出发还是从头节点出发：LinkedNode *cur = _dummyHead->next;还是LinkedNode *cur = _dummyHead;
• 要记录size
• 区分while（–i）和while（i–）
  • while（–i）：先–i然后再判断while
  • while（i–）：先i–然后再判断while

代码：

class MyLinkedList {
public:
    struct LinkedNode {
        int val;
        LinkedNode *next;
        LinkedNode(int val):val(val),next(NULL){};
    };

    MyLinkedList() {
        _dummyHead = new LinkedNode(0);
        _size = 0;
    }
    
    int get(int index) {
        if(index < 0 || index > (_size - 1)) return -1;
        LinkedNode *cur = _dummyHead->next;
        while(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;
        //有可能只有dummyhead;因此不能LinkedNode *cur = _dummyHead->next;
        while(cur->next != NULL) {
            cur = cur->next;
        }
        cur->next = newNode;
        newNode->next = NULL;
        _size++; 
    }
    
    void addAtIndex(int index, int val) {
        if(index > _size) return;
        if(index < 0) index = 0;
        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 < 0 || index >= _size) return;
        LinkedNode *cur = _dummyHead;
        while(index--) {
            cur = cur->next;
        } 
        LinkedNode *tmp = cur->next;
        cur->next = cur->next->next;
        delete tmp;
        _size--;
    }
private:
    int _size;
    LinkedNode* _dummyHead;
};

/**
 * 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);
 */

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/design-linked-list
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

---

24. 两两交换链表中的节点（中等）

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

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

示例 2：
输入：head = []
输出：[]

示例 3：
输入：head = [1]
输出：[1]

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

思路：

• 创建虚拟头节点；然后三个三个为一组；

  • 对于[1,2,3,4]这一个示例：

    • 例如第一次；cur->dummyHead；然后使用多一个指针指向3；然后2指向1；1指向3；cur指向2；
    • 第二次时cur指向1；
    • 

  • 善于使用虚拟节点，可以减少对头节点特殊情况的处理；

代码：

/**
 * 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 *dummyHead = new ListNode(0);
        dummyHead->next = head;
        ListNode *cur = dummyHead;
        while(cur->next != NULL && cur->next->next != NULL) {
            ListNode *pre = cur->next;
            ListNode *next = cur->next->next;
            ListNode *tmp = next->next;

            next->next = pre;
            pre->next = tmp;
            cur->next = next;

            cur = cur->next->next;
        }
        return dummyHead->next;
    }
};

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/swap-nodes-in-pairs
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

---

19. 删除链表的倒数第 N 个结点（中等）

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

思路：

• 使用栈先进后出的特点；倒数第n个就是stack.pop( )n次后stack.top( )元素；
• 善于使用虚拟节点；

代码：

/**
 * 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) {
        stack<ListNode*> s;
        ListNode *dummyHead = new ListNode(0);
        dummyHead->next = head;
        ListNode *cur = dummyHead;
        while(cur != NULL) {
            s.push(cur);
            cur = cur->next;
        }
        while(n--) {
            s.pop();
        }
        ListNode *prev = s.top();
        ListNode *tmp = prev->next;
        prev->next = tmp->next;
        delete tmp;
        return dummyHead->next;
    }
};

思路2

• 倒数第n个；可以理解成和最后一个元素相差n个；那么只要定义双指针；先让fastIndex先走n步；然后slowIndex和fastIndex同时开始；当fastIndex到达最后一个指针时；slowIndex指向的下一个节点就是倒数第n个；
• 还是要创建虚拟节点；

代码：

/**
 * 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) {
        if(head == NULL) return NULL;
        ListNode *dummyHead = new ListNode();
        dummyHead->next = head;
        ListNode *slowIndex = dummyHead;
        ListNode *fastIndex = dummyHead;
        while(n--) {
            fastIndex = fastIndex->next;
        }
        while(fastIndex->next != NULL) {
            fastIndex = fastIndex->next;
            slowIndex = slowIndex->next;
        }
        ListNode *tmp = slowIndex->next;
        slowIndex->next = slowIndex->next->next;
        delete tmp;
        return dummyHead->next;
    }
};