【LeetCode刷题week2】——链表专题

TBD1

已于 2022-02-21 17:25:27 修改

阅读量521

点赞数

分类专栏： LeetCode专题文章标签：链表 leetcode 算法数据结构 c++

于 2022-02-20 23:33:28 首次发布

本文链接：https://blog.csdn.net/qq_41084649/article/details/122973883

版权

LeetCode专题专栏收录该内容

6 篇文章 0 订阅

订阅专栏

LC 链表专题

[声明]：ACWing Y总课程总结

1.题目链接

2009年408真题——408元年的数据结构算法题！！！

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

输入 / 输出样例

输入：head = [1,2,3,4,5], n = 2
输出：[1,2,3,5]
------------------------
输入：head = [1], n = 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* removeNthFromEnd(ListNode* head, int n) {
        auto dummy = new ListNode(-1);
        dummy->next = head; // 创建虚拟头结点, 并指向head
        // 虚拟头结点目的是为了防止头结点被删掉
        auto first = dummy, second = dummy;\
        while(n --) first = first->next;
        while(first->next){ // first 为 nullptr 退出
            first = first->next;
            second = second->next;
        }
        second->next = second->next->next; // delete

        return dummy->next; // 虚拟头结点的下一个结点一定是头结点, 且预防了头结点被删除
    }
};

2.题目链接

LeetCode237. 删除链表中的节点

输入 / 输出样例

输入：head = [4,5,1,9], node = 5
输出：[4,1,9]

思路：伪装成下一个节点，把下一个结点删除即可

代码如下：

版本一

class Solution {
public:
    void deleteNode(ListNode* node) { // node是给定结点
        node->val = node->next->val;
        node->next = node->next->next;
    }
};

版本二

class Solution {
public:
    void deleteNode(ListNode* node) { // node是给定结点
         *(node) = *(node->next);  // 将结构体整段赋值
    }
};

3.题目链接

LeetCode83. 删除排序链表中的重复元素

输入 / 输出样例

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

代码如下：
1.方法一：

class Solution {
public:
    ListNode* deleteDuplicates(ListNode* head) {
        auto dummy = new ListNode(-1);
        dummy->next = head;
        auto p = dummy;
        while(p->next){
            if(p->next->val == p->val){
                p->next = p->next->next;
                continue;
            }
            else{
                p = p->next;
            }
        }
        return head;
    }
};

2.y总代码

class Solution {
public:
    ListNode* deleteDuplicates(ListNode* head) {
        auto p = head;
        while(p){
            if(p->next && p->next->val == p->val)
                p->next = p->next->next;
            else p = p->next;
        }
        return head;
    }
};

4.题目链接

LeetCode61. 旋转链表

在这里插入图片描述

输入 / 输出样例

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

代码如下：

class Solution {
public:
    ListNode* rotateRight(ListNode* head, int k) {
        if(!head) return nullptr;
        int n = 0;
        for(auto p = head; p; p = p->next) n++;
        k %= n;
        auto first = head, second = head;
        while(k--) first = first->next;
        while(first->next){
            first = first->next;
            second = second->next;
        }

        first->next = head;
        head = second->next;
        second->next = nullptr;

        return head;
    }
};

5.题目链接

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

在这里插入图片描述

输入 / 输出样例

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

代码如下：

class Solution {
public:
    ListNode* swapPairs(ListNode* head) {
        if(!head) return nullptr;
        auto dummy = new ListNode(-1);
        dummy->next = head;

        auto p = dummy;
        while(p->next && p->next->next){
            auto a = p->next;
            auto b = a->next;
            // 交换相邻结点
            p->next = b;
            a->next = b->next;
            b->next = a;
            p = a;
        }
        return dummy->next;
    }
};

6.题目链接

LeetCode206. 反转链表

在这里插入图片描述

输入 / 输出样例

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

代码如下：

class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        if(!head) return nullptr;
        auto a = head;
        auto b = a->next;
        while(b){
            auto c = b->next;
            b->next = a;
            a = b;
            b = c;
        }
        head->next = nullptr; // 头结点变为尾结点
        return a; // a为新的头结点
    }
};

7.题目链接

LeetCode92. 反转链表 II

在这里插入图片描述

输入 / 输出样例

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

代码如下

class Solution {
public:
    ListNode* reverseBetween(ListNode* head, int m, int n) {
        if(m == n) return head;
        auto dummy = new ListNode(-1);
        dummy->next = head;

        auto a = dummy, d = dummy;
        for(int i = 0; i < m-1; i++) a = a->next; // a为m-1位置的结点
        for(int i = 0; i < n; i++) d = d->next;   // d为n位置的结点

        auto b = a->next, c = d->next;
        // [模板]反转链表
        auto p = b, q = b->next; // p q r为模板的a b c
        while(q != c){ // 反转区间[b,d]
            auto r = q->next;
            q->next = p;
            p = q;
            q = r;
        }  

        b->next = c;
        a->next = d;
        return dummy->next;
    }
};

8.题目链接

LeetCode160. 相交链表

示例
在这里插入图片描述
思路：

p从ListA开始遍历，q从ListB开始遍历，都遍历完后。换链表遍历，一定会同时相交
代码如下

class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        auto p = headA, q = headB;
        while(p != q){ // p q相遇时退出
            if(p) p = p->next;
            else p = headB; // 若p空, 则继续遍历B
            if(q) q = q->next;
            else q = headA; // 若q空, 则继续遍历A
        }

        return p;
    }
};

9.题目链接

LeetCode142. 环形链表 II

示例
在这里插入图片描述

在这里插入图片描述
自己分析（破烂证明）：

∵ fast和slow一定会相遇，假设在c点相遇，b~c = y，C为环周长，n为圈数
fast距离: x + nC + y
slow距离: x+y
∵ x + nC + y = 2x + 2y
∴ x = nC -y
∴ x+y=nC
不妨设n = 1
∴ x+y = C
∴ c~b = x
即 c~b = a~b = x
∴ 将一个指针移到head，两个指针同时移动x距离后，一定在环的入口相遇。
得证！

代码

class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
        auto fast = head, slow = head;
        while(slow){
            fast = fast->next;
            slow = slow->next;
            if(slow) slow = slow->next;
            else break;
            
            if(fast == slow){
                fast = head;
                while(fast != slow){
                    fast = fast->next;
                    slow = slow->next;
                }
                return fast;
            }
        }
        return NULL;
    }
};

10.题目链接 ★★

LeetCode148. 排序链表

略难

在这里插入图片描述

代码如下

class Solution {
public:
    ListNode* sortList(ListNode* head) {
        int n = 0;
        for(auto p = head; p; p = p->next) n++;
        auto dummy = new ListNode(-1);
        dummy->next = head;
        for(int i = 1; i < n; i *= 2){ // 归并长度
            auto cur = dummy;
            for(int j = 0; j + i < n; j += i * 2){ // 每次扫描长度为 2*i 的归并段
                // left为左归并段端点, right为右归并段端点
                auto left = cur->next, right = cur->next;
                for(int k = 0; k < i; k++) right = right->next; // right为第二个归并段的左端点
                int l = 0, r = 0;  // l r记录当前左/右归并段是否遍历完
                // ★归并两段长度为 i 的区间
                while(l < i && r < i && left && right){
                    if(left->val <= right->val){ // 归并排序 l_a <= r_b
                        cur->next = left;
                        cur = left;
                        left = left->next;
                        l ++;
                    }else{ // 归并排序 l_a > r_b
                        cur->next = right;
                        cur = right;
                        right = right->next;
                        r ++;
                    }
                }
                // 归并最后剩余的部分
                while(l < i && left){
                    cur->next = left;
                    cur = left;
                    left = left->next;
                    l ++;
                }
                while(r < i && right){
                    cur->next = right;
                    cur = right;
                    right = right->next;
                    r ++;
                }
                cur->next = right;
            } // for j
        } // for i
        return dummy->next;
    }
};