C++算法题 - 链表

最新推荐文章于 2025-03-25 17:55:45 发布

x_fengmo

最新推荐文章于 2025-03-25 17:55:45 发布

阅读量1.2k

点赞数 15

分类专栏：力扣算法文章标签： c++ 算法链表

本文链接：https://blog.youkuaiyun.com/x_fengmo/article/details/138153866

版权

力扣算法专栏收录该内容

13 篇文章

订阅专栏

141. 环形链表

LeetCode_link

给你一个链表的头节点 head ，判断链表中是否有环。

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

如果链表中存在环 ，则返回 true 。否则，返回 false 。

示例 1：
在这里插入图片描述
输入：head = [3,2,0,-4], pos = 1
输出：true
解释：链表中有一个环，其尾部连接到第二个节点。

示例 2：
在这里插入图片描述
输入：head = [1,2], pos = 0
输出：true
解释：链表中有一个环，其尾部连接到第一个节点。

示例 3：
在这里插入图片描述
输入：head = [1], pos = -1
输出：false
解释：链表中没有环。

提示：
链表中节点的数目范围是 [0, 10^4]
-10^5 <= Node.val <= 10^5
pos 为 -1 或者链表中的一个 有效索引 。

思路：一个指针的前进为1格，一个为两格，如果两格追上了一个格，就是有环；否则就是没有。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    bool hasCycle(ListNode *head) {
        ListNode* l1 = head;
        ListNode* l2 = head;
        while(l2 != NULL && l2->next != NULL){
            l1 = l1->next;
            l2 = l2->next->next;
            if(l1 == l2)    return true;
        }
        return false;
        
    }
};

2. 两数相加

LeetCode_link

给你两个非空的链表，表示两个非负的整数。它们每位数字都是按照逆序的方式存储的，并且每个节点只能存储一位数字。

请你将两个数相加，并以相同形式返回一个表示和的链表。

你可以假设除了数字 0 之外，这两个数都不会以 0 开头。

示例 1：
在这里插入图片描述
输入：l1 = [2,4,3], l2 = [5,6,4]
输出：[7,0,8]
解释：342 + 465 = 807.

示例 2：
输入：l1 = [0], l2 = [0]
输出：[0]

示例 3：
输入：l1 = [9,9,9,9,9,9,9], l2 = [9,9,9,9]
输出：[8,9,9,9,0,0,0,1]

提示：
每个链表中的节点数在范围 [1, 100] 内
0 <= Node.val <= 9
题目数据保证列表表示的数字不含前导零

思路：答案返回的是新链表

/**
 * 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 *n1 = l1;
        ListNode *n2 = l2;
        ListNode *head = new ListNode(1, nullptr);
        ListNode *run = head;
        int c = 0;
        while(n1 != nullptr && n2 != nullptr){
            ListNode *t = new ListNode((n1->val + n2->val + c) % 10, nullptr);
            run->next = t;
            run = run->next;
            c = (n1->val + n2->val + c) / 10;
            n1 = n1->next;
            n2 = n2->next;
        }
        while(n1 != nullptr){
            ListNode *t = new ListNode((n1->val + c) % 10, nullptr);
            run->next = t;
            run = t;
            c = (n1->val + c) / 10;
            n1 = n1->next;
        }
        while(n2 != nullptr){
            ListNode *t = new ListNode((n2->val + c) % 10, nullptr);
            run->next = t;
            run = t;
            c = (n2->val + c) / 10;
            n2 = n2->next;
        }
        if(c == 1){
            ListNode *t = new ListNode(1, nullptr);
            run->next = t;
        }
        return head->next;
    }
};

21. 合并两个有序链表

LeetCode_link

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

示例 1：
在这里插入图片描述
输入：l1 = [1,2,4], l2 = [1,3,4]
输出：[1,1,2,3,4,4]

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

示例 3：
输入：l1 = [], l2 = [0]
输出：[0]

提示：
两个链表的节点数目范围是 [0, 50]
-100 <= Node.val <= 100
l1 和 l2 均按 非递减顺序 排列

思路：答案返回的是新链表

/**
 * 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) {
        ListNode *head = new ListNode();
        ListNode *end = head;
        while(list1 != nullptr && list2 != nullptr){
            if(list1->val <= list2->val){
                end->next = list1;
                list1 = list1->next;
            }else{
                end->next = list2;
                list2 = list2->next;
            }
            end = end->next;
        }
        if(list1 != nullptr){
            end -> next = list1;
        }
        if(list2 != nullptr){
            end -> next = list2;
        }
        return head->next;
    }
};

138. 随机链表复制

LeetCode_link

给你一个长度为 n 的链表，每个节点包含一个额外增加的随机指针 random ，该指针可以指向链表中的任何节点或空节点。

构造这个链表的深拷贝。深拷贝应该正好由 n 个全新节点组成，其中每个新节点的值都设为其对应的原节点的值。新节点的 next 指针和 random 指针也都应指向复制链表中的新节点，并使原链表和复制链表中的这些指针能够表示相同的链表状态。复制链表中的指针都不应指向原链表中的节点 。

例如，如果原链表中有 X 和 Y 两个节点，其中 X.random --> Y 。那么在复制链表中对应的两个节点 x 和 y ，同样有 x.random --> y 。

返回复制链表的头节点。

用一个由 n 个节点组成的链表来表示输入/输出中的链表。每个节点用一个 [val, random_index] 表示：

val：一个表示 Node.val 的整数。
random_index：随机指针指向的节点索引（范围从 0 到 n-1）；如果不指向任何节点，则为 null 。

你的代码只接受原链表的头节点 head 作为传入参数。

示例 1：
在这里插入图片描述
输入：head = [[7,null],[13,0],[11,4],[10,2],[1,0]]
输出：[[7,null],[13,0],[11,4],[10,2],[1,0]]

示例 2：
在这里插入图片描述
输入：head = [[1,1],[2,1]]
输出：[[1,1],[2,1]]

示例 3：
在这里插入图片描述
输入：head = [[3,null],[3,0],[3,null]]
输出：[[3,null],[3,0],[3,null]]

提示：
0 <= n <= 1000
-10^4 <= Node.val <= 10^4
Node.random 为 null 或指向链表中的节点。

思路：用哈希表在给随机指针赋值的时候快速找到老节点对应的新节点。

/*
// Definition for a Node.
class Node {
public:
    int val;
    Node* next;
    Node* random;
    
    Node(int _val) {
        val = _val;
        next = NULL;
        random = NULL;
    }
};
*/

class Solution {
private:
    unordered_map<Node*, Node*> hash;
public:
    Node* copyRandomList(Node* head) {
        Node *n1 = head;
        Node *creat = new Node(0);
        Node *n2 = creat;
        while(n1 != NULL){
            Node *temp = new Node(n1->val);
            n2->next = temp;
            hash[n1] = temp;
            n2 = n2->next;
            n1 = n1->next;
        }
        n2->next = NULL;
        n2 = creat->next;
        n1 = head;
        while(n1 != NULL){
            n2->random = hash[n1->random];
            n1 = n1->next;
            n2 = n2->next;
        }
        return creat->next;
    }
};

92. 反转链表Ⅱ

LeetCode_link

给你单链表的头指针 head 和两个整数 left 和 right ，其中 left <= right 。请你反转从位置 left 到位置 right 的链表节点，返回反转后的链表。

示例 1：
在这里插入图片描述
输入：head = [1,2,3,4,5], left = 2, right = 4
输出：[1,4,3,2,5]

示例 2：
输入：head = [5], left = 1, right = 1
输出：[5]

提示：
链表中节点数目为 n
1 <= n <= 500
-500 <= Node.val <= 500
1 <= left <= right <= 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* reverseBetween(ListNode* head, int left, int right) {
        int count = 1;
        ListNode *n = head;
        ListNode *end, *start, *left_pre;
        while(count <= right){
            if(left > 1 && count == left - 1){
                left_pre = n;
            }else if(count == left){
                ListNode *temp = new ListNode(n->val, nullptr);
                start = temp;
                end = temp;
            }else if(count > left){
                ListNode *temp = new ListNode(n->val, start);
                start = temp;
            }
            n = n->next;
            count ++;
        }
        if(left == 1){
            head = start;
        }else{
            left_pre->next = start;
        }
        end->next = n;
        return head;

    }
};

25. K个一组翻转链表

LeetCode_link

给你链表的头节点 head ，每 k 个节点一组进行翻转，请你返回修改后的链表。

k 是一个正整数，它的值小于或等于链表的长度。如果节点总数不是 k 的整数倍，那么请将最后剩余的节点保持原有顺序。

你不能只是单纯的改变节点内部的值，而是需要实际进行节点交换。

示例 1：
在这里插入图片描述
输入：head = [1,2,3,4,5], k = 2
输出：[2,1,4,3,5]

示例 2：
在这里插入图片描述
输入：head = [1,2,3,4,5], k = 3
输出：[3,2,1,4,5]

提示：
链表中的节点数目为 n
1 <= k <= n <= 5000
0 <= Node.val <= 1000

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

/**
 * 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* reverseKGroup(ListNode* head, int k) {
        ListNode *pre = nullptr, *right = head, *first;
        ListNode *start = nullptr, *end = nullptr;
        while(right != nullptr){
            vector<ListNode*> rec = reverse(right, k);
            start = rec[0], end = rec[1], right = rec[2];
            if(start == nullptr && end == nullptr)  break;
            if(pre == nullptr){
                head = start;
                pre = end;
            }else{
                pre->next = start;
                pre = end;
            }
            first = right;
        }
        pre->next = first;
        return head;

    }
    vector<ListNode*> reverse(ListNode* right, int k){
        if(right == nullptr)    return {nullptr, nullptr, nullptr};
        ListNode *start, *end;
        for(int i = 0; i < k; i++){
            ListNode *temp = new ListNode(right->val);
            if(i == 0){
                end = temp;
                start = temp;
            }else{
                temp -> next = start;
                start = temp;
            }
            right = right -> next;
            if(right == nullptr && i < k-1)    return{nullptr,nullptr,right};
        }
        return {start, end, right};
    }
};

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

LeetCode_link

给你一个链表，删除链表的倒数第 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]

提示：
链表中结点的数目为 sz
1 <= sz <= 30
0 <= Node.val <= 100
1 <= n <= sz

思路：让一个指针先走K步，然后前指针后指针同时往后走，当前指针走到结尾了，后指针就指向了应该删除的位置。

/**
 * 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 *front = head, *back = head, *pre = head;
        while(n > 1){
            front = front->next;
            if(front == nullptr)    return nullptr;
            n--;
        }
        if(front->next == nullptr){
            head = head->next;
            return head;
        }
        while(front->next!=nullptr){
            if(back != head)    pre = pre->next;
            front = front->next;
            back = back->next;
        }
        pre->next = back->next;
        return head;
    }
};

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

LeetCode_link

给定一个已排序的链表的头 head ，删除原始链表中所有重复数字的节点，只留下不同的数字。返回已排序的链表。

示例 1：
在这里插入图片描述
输入：head = [1,2,3,3,4,4,5]
输出：[1,2,5]

示例 2：
在这里插入图片描述
输入：head = [1,1,1,2,3]
输出：[2,3]

提示：
链表中节点数目在范围 [0, 300] 内
-100 <= Node.val <= 100
题目数据保证链表已经按升序排列

思路：

/**
 * 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* deleteDuplicates(ListNode* head) {
        if(head == nullptr) return nullptr;
        ListNode *start = head, *end = head ,*pre = head;
        int num = head->val;
        while(end->next != nullptr){
            while(end->next != nullptr && end->next->val == num){
                end = end->next;
            }
            if(start == end){
                pre = end;
            }else{
                if(start == head){
                    head = end->next;
                }else{
                    pre->next = end->next;
                }
            }
            if(end->next != nullptr){
                start = end->next;
                end = end->next;
                num = start->val;
            }
        }
        return head;
    }
};

61. 旋转链表

LeetCode_link

给你一个链表的头节点 head ，旋转链表，将链表每个节点向右移动 k 个位置。

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

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

提示：
链表中节点的数目在范围 [0, 500] 内
-100 <= Node.val <= 100
0 <= k <= 2 * 10^9

思路：1、统计链表的长度；2、计算需要移动的位置，按照链表长度取余；3、用前后指针指向前半部分的尾和后半部分的尾，back指针和front指针分别指向图中位置；4、断开重新连接
在这里插入图片描述

/**
 * 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* rotateRight(ListNode* head, int k) {
        if(head == nullptr) return nullptr;
        ListNode *front = head, *back = head;
        int n = 0;
        //统计链表的长度
        while(front != nullptr){
            n++;
            front = front->next;
        }
        //计算需要移动的位置，按照链表长度取余
        n = k % n;
        //用前后指针指向前半部分的尾和后半部分的尾
        front = head;
        while(n--){
            front = front->next;
        }
        while(front->next != nullptr){
            front = front->next;
            back = back->next;
        }
        //重新连接
        front->next = head;
        head = back->next;
        back->next = nullptr;
        return head;
    }
};

86. 分隔链表

LeetCode_link

给你一个链表的头节点 head 和一个特定值 x ，请你对链表进行分隔，使得所有小于 x 的节点都出现在 大于或等于 x 的节点之前。

你应当保留两个分区中每个节点的初始相对位置。

示例 1：
在这里插入图片描述
输入：head = [1,4,3,2,5,2], x = 3
输出：[1,2,2,4,3,5]

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

提示：
链表中节点的数目在范围 [0, 200] 内
-100 <= Node.val <= 100
-200 <= x <= 200

思路：把链表拆成两个链表，一个放小于的，一个放大于等于的，因为要保持相对位置，所以需要尾插法，最后再连上即可。

/**
 * 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* partition(ListNode* head, int x) {
        ListNode *head1 = new ListNode(), *end1 = head1;
        ListNode *head2 = new ListNode(), *end2 = head2;
        while(head != nullptr){
            if(head->val < x){
                end1->next = head;
                head = head->next;
                end1 = end1->next;
                end1->next = nullptr;
            }else{
                end2->next = head;
                head = head->next;
                end2 = end2->next;
                end2->next = nullptr;
            }
        }
        end1->next = head2->next;
        return head1->next;
    }
};

146. LRU缓存

LeetCode_link

请你设计并实现一个满足 LRU (最近最少使用) 缓存约束的数据结构。
实现 LRUCache 类：

LRUCache(int capacity) 以 正整数 作为容量 capacity 初始化 LRU 缓存
int get(int key) 如果关键字 key 存在于缓存中，则返回关键字的值，否则返回 -1 。
void put(int key, int value) 如果关键字 key 已经存在，则变更其数据值 value ；如果不存在，则向缓存中插入该组 key-value 。如果插入操作导致关键字数量超过 capacity ，则应该逐出最久未使用的关键字。
函数 get 和 put 必须以 O(1) 的平均时间复杂度运行。

示例：

输入
["LRUCache", "put", "put", "get", "put", "get", "put", "get", "get", "get"]
[[2], [1, 1], [2, 2], [1], [3, 3], [2], [4, 4], [1], [3], [4]]
输出
[null, null, null, 1, null, -1, null, -1, 3, 4]

解释
LRUCache lRUCache = new LRUCache(2);
lRUCache.put(1, 1); // 缓存是 {1=1}
lRUCache.put(2, 2); // 缓存是 {1=1, 2=2}
lRUCache.get(1);    // 返回 1
lRUCache.put(3, 3); // 该操作会使得关键字 2 作废，缓存是 {1=1, 3=3}
lRUCache.get(2);    // 返回 -1 (未找到)
lRUCache.put(4, 4); // 该操作会使得关键字 1 作废，缓存是 {4=4, 3=3}
lRUCache.get(1);    // 返回 -1 (未找到)
lRUCache.get(3);    // 返回 3
lRUCache.get(4);    // 返回 4

提示：
1 <= capacity <= 3000
0 <= key <= 10000
0 <= value <= 10^5
最多调用 2 * 10^5 次 get 和 put

思路：双向链表+哈希表，头节点value存放剩余缓存数量。

class LRUCache {
public:
    struct ListNode {
        int key;
        int value;
        ListNode *next, *last;
        ListNode(int k, int v,ListNode* l, ListNode* n) :  key(k), value(v), last(l), next(n) {}
    };
    ListNode *head, *tail;
    unordered_map<int, ListNode*> hash; // key, node

    LRUCache(int capacity) {
        head = new ListNode(-1, capacity, nullptr, nullptr);
        tail = new ListNode(-1,-1, nullptr, nullptr);
        head->next = tail;
        tail->last = head;
    }
    
    int get(int key) {
        if(hash.find(key) == hash.end()){
            return -1;
        }else{
            //找到le
            ListNode *n = hash[key];
            if(n->next == tail){
                return n->value;
            }else{
                remove(n);
                insert_tail(n);
                return n->value;
            }
        }
        return -1;
    }
    
    void put(int key, int value) {
        if(hash.find(key) == hash.end()){
            //没找到
            if(head->value > 0){
                //还有余量，直接插入就行
                ListNode *temp = new ListNode(key, value, nullptr, nullptr);
                hash[key] = temp;
                insert_tail(temp);
                head->value--;
            }else{
                //没有余量了
                int last_key = head->next->key;
                remove(head->next);
                hash.erase(last_key);
                ListNode *temp = new ListNode(key, value, nullptr, nullptr);
                hash[key] = temp;
                insert_tail(temp);
            }
        }else{
            //找到了
            ListNode *n = hash[key];
            if(n->next == tail){
                n->value = value;
            }else{
                remove(n);
                insert_tail(n);
                n->value = value;
            }
        }
    }
    void remove(ListNode* n){
        n->last->next = n->next;
        n->next->last = n->last;
    }
    void insert_tail(ListNode* n){
        n->last = tail->last;
        tail->last->next = n;
        tail->last = n;
        n->next = tail;
    }
};

/**
 * Your LRUCache object will be instantiated and called as such:
 * LRUCache* obj = new LRUCache(capacity);
 * int param_1 = obj->get(key);
 * obj->put(key,value);
 */