leetcode链表题目汇总

已于 2022-03-07 00:10:55 修改
阅读量237 收藏
点赞数
分类专栏： C++ 算法 文章标签： leetcode
于 2021-08-25 18:36:43 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_21237549/article/details/119910244
版权
C++ 同时被 2 个专栏收录
55 篇文章 0 订阅
订阅专栏
算法
22 篇文章 0 订阅
订阅专栏
本文涵盖了多种链表操作的算法实现，包括反转链表、链表区间反转、链表排序、查找回文和环形链表等。此外，还涉及合并两个有序链表、插入排序链表、在环形链表中找到环的入口节点等复杂操作。这些算法展示了链表数据结构在解决计算机科学问题中的应用。
摘要由CSDN通过智能技术生成

206. 反转链表

https://leetcode-cn.com/problems/reverse-linked-list/

/**
 * 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* prev=NULL;
        while(head!=NULL){
            ListNode* next=head->next;
            head->next=prev;
            prev=head;
            head=next;
        }
        return prev;
    }
};

92. 反转链表 II

https://leetcode-cn.com/problems/reverse-linked-list-ii/

/**
 * 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) {
        ListNode* in,out;
        ListNode* root=head;
        if(left==right)return head;
        int cnt=0;
        ListNode* prev=NULL;
        while(head!=NULL){
            cnt++;
            if(cnt==left){
                in=prev;
                prev=head;
                head=head->next;
                continue;
            }
            if(cnt>left&&cnt<=right){
                ListNode* next=head->next;
                head->next=prev;
                prev=head;
                head=next;
                if(cnt==right){
                    if(left==1){
                        root->next=head;
                        return prev;
                    }
                    ListNode* temp=in->next;
                    in->next=prev;
                    temp->next=head;
                    return root;
                }
                continue;
            }
            prev=head;
            head=head->next;
        }
        return root;
    }
};

143. 重排链表

https://leetcode-cn.com/problems/reorder-list/

/**
 * 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:
    void reorderList(ListNode* head) {
        if(head==NULL)return;
        stack<ListNode*>S;
        ListNode* root=head;
        int cnt=0;
        while(root!=NULL){
            cnt++;
            S.push(root);
            root=root->next;
        }
        ListNode* h=head;
        ListNode* now=head->next;
        if(now==NULL)return;
        for(int i=2;i<=cnt;i++){
            if(i%2==0){
                h->next=S.top();
                S.pop();
                h=h->next;
            }else{
                h->next=now;
                h=h->next;
                now=now->next;
            }
        }
        h->next=NULL;
        return;
    }
};

148. 排序链表

https://leetcode-cn.com/problems/sort-list/

/**
 * 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* a[110000];
    static int cmp(ListNode* x,ListNode* y){
        if(x->val<y->val)return 1;
        return 0;
    }
    ListNode* sortList(ListNode* head) {
        if(head==NULL)return head;
        int n=0;
        while(head!=NULL){
            n++;
            a[n]=head;
            head=head->next;
        }
        sort(a+1,a+n+1,cmp);
        ListNode* root=a[1];
        ListNode* now=root;
        for(int i=2;i<=n;i++){
            now->next=a[i];
            now=now->next;
        }
        now->next=NULL;
        return root;
    }
};

234. 回文链表

https://leetcode-cn.com/problems/palindrome-linked-list/

/**
 * 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* Q[110000];
    int cnt=0;
    bool isPalindrome(ListNode* head) {
        while(head){
            cnt++;
            Q[cnt]=head;
            head=head->next;
        }
        for(int i=1;i<=cnt/2;i++){
            if(Q[i]->val!=Q[cnt-i+1]->val)return false;
        }
        return true;
    }
};

21. 合并两个有序链表

https://leetcode-cn.com/problems/merge-two-sorted-lists/

/**
 * 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* l1, ListNode* l2) {
        if(l1==NULL)return l2;
        if(l2==NULL)return l1;
        ListNode* root=new ListNode();
        ListNode* now=root;
        for(;;){
            if(l1==NULL&&l2==NULL)break;
            if((l1!=NULL)&&(l2==NULL||(l1->val<l2->val))){
                now->next=l1;
                l1=l1->next;
            }else{
                now->next=l2;
                l2=l2->next;
            }
            now=now->next;
        }
        root=root->next;
        return root;
    }
};

147. 对链表进行插入排序

https://leetcode-cn.com/problems/insertion-sort-list/

/**
 * 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* insertionSortList(ListNode* head) {
        ListNode* root=new ListNode();
        root->val=head->val;
        head=head->next;
        while(head!=NULL){
            ListNode* prev=NULL;
            ListNode* now=root;
            while(now->val<head->val){
                prev=now;
                now=now->next;
                if(now==NULL)break;
            }
            if(prev==NULL){
                ListNode* temp=new ListNode();
                temp->val=head->val;
                temp->next=root;
                root=temp;
            }else{
                ListNode* temp=new ListNode();
                temp->next=now;
                temp->val=head->val;
                prev->next=temp;
            }
            head=head->next;
        }
        return root;
    }
};

142. 环形链表 II

https://leetcode-cn.com/problems/linked-list-cycle-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) {
        ListNode* slow=head;
        ListNode* fast=head;
        while(1){
            if(fast==NULL)return NULL;
            fast=fast->next;
            if(fast==NULL)return NULL;
            fast=fast->next;
            slow=slow->next;
            if(fast==NULL)return NULL;
            if(fast==slow)break;
        }
        while(head!=slow){
            head=head->next;
            slow=slow->next;
        }
        return head;
    }
};

141. 环形链表

https://leetcode-cn.com/problems/linked-list-cycle/

/**
 * 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) {
        for(int i=1;i<=20000;i++){
            if(head==NULL){
                return false;
            }
            head=head->next;
        }
        return true;
    }
};

23. 合并K个升序链表

https://leetcode-cn.com/problems/merge-k-sorted-lists/

/**
 * 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:
    struct data{
        int val,id;
        bool operator<(const data &up)const{
            return val>up.val;
        }
    };
    priority_queue<data>q;
    ListNode* mergeKLists(vector<ListNode*>& lists) {
        ListNode* head=new ListNode();
        ListNode* tail=head;
        int n=lists.size();
        for(int i=0;i<n;i++){
            if(lists[i]!=NULL)q.push({lists[i]->val,i});
        }
        ListNode* temp;
        bool flag=0;
        while(q.size()){
            flag=1;
            data now=q.top();
            q.pop();
            tail->val=now.val;
            ListNode* po=new ListNode();
            tail->next=po;
            temp=tail;
            tail=po;
            lists[now.id]=lists[now.id]->next;
            if(lists[now.id]!=NULL){
                q.push({lists[now.id]->val,now.id});
            }
        }
        if(flag==0)return NULL;
        temp->next=NULL;
        return head;
    }
};

1669. 合并两个链表

参考：https://leetcode-cn.com/problems/merge-in-between-linked-lists/

/**
 * 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* mergeInBetween(ListNode* list1, int a, int b, ListNode* list2) {
        ListNode* L2H=list2;
        ListNode* L2T=L2H;
        while(L2T->next!=NULL)L2T=L2T->next;
        int id=0;
        ListNode* now=list1;
        ListNode* mark1;
        ListNode* mark2;
        for(;;){
            if(id==a-1)mark1=now;
            if(id==b+1)mark2=now;
            id++;
            now=now->next;
            if(now==NULL)break;
        }
        mark1->next=L2H;
        L2T->next=mark2;
        return list1;
    }
};

剑指 Offer 18. 删除链表的节点

参考：https://leetcode-cn.com/problems/shan-chu-lian-biao-de-jie-dian-lcof/

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* deleteNode(ListNode* head, int val) {
        ListNode* res=new ListNode();
        ListNode* tail=res;
        while(head){
            if(head->val!=val){
                ListNode* po=new ListNode();
                po->val=head->val;
                tail->next=po;
                tail=po;
            }
            head=head->next;
        }
        res=res->next;
        return res;
    }
};

6013. 合并零之间的节点

https://leetcode-cn.com/problems/merge-nodes-in-between-zeros/

/**
 * 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* mergeNodes(ListNode* head) {
        head=head->next;
        ListNode* now=head;
        while(now!=NULL){
            while(now->next->val>0){
                now->val+=now->next->val;
                now->next=now->next->next;
            }
            now->next=now->next->next;
            now=now->next;
        }
        return head;
    }
};

6018. 根据描述创建二叉树

参考：https://leetcode-cn.com/contest/weekly-contest-283/problems/create-binary-tree-from-descriptions/

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    map<int,TreeNode*>M;
    map<int,int>f;
    TreeNode* createBinaryTree(vector<vector<int>>& d) {
        for(int i=0;i<d.size();i++){
            int x=d[i][0],y=d[i][1],z=d[i][2];
            if(M.count(x)==0)M[x]=new TreeNode(),M[x]->val=x;
            if(M.count(y)==0)M[y]=new TreeNode(),M[y]->val=y;
            if(f.count(x)==0)f[x]=0;
            if(f.count(y)==0)f[y]=0;
            f[y]++;
            if(z==1)M[x]->left=M[y];
            if(z==0)M[x]->right=M[y];
        }
        int mark=0;
        for(auto x:f){
            if(x.second==0){
                mark=x.first;
                break;
            }
        }
        return M[mark];
    }
};

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    TreeNode* createBinaryTree(vector<vector<int>>& ds) {
        map<int,TreeNode*>L;
        set<int>C;
        for(auto x:ds){
            int fa = x[0];
            int ch = x[1];
            int re = x[2];
            if(L.find(fa)==L.end())L[fa]=new TreeNode(fa);
            if(L.find(ch)==L.end())L[ch]=new TreeNode(ch);
            if(re)L[fa]->left = L[ch];
            else L[fa]->right = L[ch];
            C.insert(ch);
        }
        int root = -1;
        for(auto pr:L)if(C.count(pr.first)==0)root=pr.first;
        return L[root];
    }
};
滚雪球~
关注
专栏目录
leetcode题目汇总.docx
03-06
以上是LeetCode题目中涉及的一些核心知识点，涵盖网络编程、数据结构（链表、数组）、算法（双指针、分治、层次遍历）以及数值处理等多个方面。通过解决这些题目，开发者可以深入理解并提升这些关键技能。
链表
yhy_13s的博客
04-19 235
一，链表整体逆序 思路： 代码 /** * 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) :
数据结构-链表复习【1】（leetcode一些整理）
最新发布
lyhhh0316的博客
04-10 104
给你两个 非空 的链表，表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的，并且每个节点只能存储 一位 数字。请你将两个数相加，并以相同形式返回一个表示和的链表。你可以假设除了数字 0 之外，这两个数都不会以 0 开头。
leetcode刷题之链表
qq_39621037的博客
10-17 388
合并两个有序链表 参考代码 普通解法 /** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x) : val(x), next(NULL) {} * }; */ class Solution { publ...
leetcode典型链表题
qq_67503717的博客
02-23 210
leetcode链表类型题基本解法
反转一个链表（复习数据结构，基础）
ambiguous__的博客
06-20 4075
将一个单链表反转 /** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x) : val(x), next(NULL) {} * }; */ class Solution { public: ListNode* reverseList(ListNode* head) { ListNod
leetcode中国-LeetCode:LeetCode经典题目分类汇总(JavaScript实现)
06-29
我对题目进行了标签分类，你也可以按 进行刷题。 数组 ( Array ) 链表 ( Linked List ) 栈 ( Stack ) 树 ( Tree ) 二叉搜索树 ( BST ) 字典树（前缀树） ( Trie ) 哈希表 ( Hash Table ) 堆 ( Heap ) 图 ( Graph ) ...
lrucacheleetcode-leetcode:leetcodeAC题目
06-29
描述中的"lru cache leetcode leetcode AC题目汇总"进一步确认了这个压缩包包含的是关于LRU缓存的LeetCode解题集合，而且所有题目都已经实现了正确答案。"目前AC题目有: other AC题目 打印沙漏"可能是指除了LRU缓存...
LeetCode 刷题汇总1
08-03
LeetCode刷题汇总1是LeetCode平台上的一系列算法题目汇总，涵盖了各种难度级别的题目，从简单到困难。以下是从这个汇总中提取的知识点： 1. 数组和链表操作： * 两数之和（Two Sum）：给定一个整数数组，找到两个...
leetcode分类-leetcode:leetcode刷题（中等难度分类）
06-30
本篇将聚焦于LeetCode中的中等难度题目，通过深入探讨这些题目，我们可以深化对数据结构和算法的理解，为面试准备或是日常开发工作打下坚实基础。 一、数据结构篇 在LeetCode的中等难度题目中，数据结构的应用是...
c代码-2.给定一个排序链表，删除所有重复的元素，使得每个元素只出现一次。 示例 1: 输入: 1->1->2 输出: 1->2 示例 2: 输入: 1->1->2->3->3 输出: 1->2->3 /** * Definition for singly-linked list. * struct ListNode { * int val; * struct ListNode *next; * }; */ struct ListNode*
07-14
c代码-2.给定一个排序链表，删除所有重复的元素，使得每个元素只出现一次。 示例 1: 输入: 1->1->2 输出: 1->2 示例 2: 输入: 1->1->2->3->3 输出: 1->2->3 /** * Definition for singly-linked list. * struct ListNode { * int val; * struct ListNode *next; * }; */ struct ListNode* deleteDuplicates(struct ListNode* head){ }
链表专题 c/c++实现 LeetCode例题讲解
RanLZ的博客
07-25 630
链表专题 首先我们都知道，链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。 一般用结构体来表示。 struct ListNode { int val; struct ListNode *next; }; 其中 valvalval 是存储这个节点的值， ∗next*next∗next 是存储下一个节点的位置。这样每一个...
重排链表题解
qq_42681040的博客
07-10 148
链接 /** * 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(ne
Leetcode题解——数据结构之链表
dieshi8689的博客
06-12 715
1. 找出两个链表的交点 2. 链表反转 3. 归并两个有序的链表 4. 从有序链表中删除重复节点 5. 删除链表的倒数第 n 个节点 6. 交换链表中的相邻结点 7. 链表求和 8. 回文链表 9. 分隔链表 10. 链表元素按奇偶聚集 链表是空节点，或者有一个值和一个指向下一个链表的指针，因此很多链表问题可以用递归来处理。 1. 找出两个链表的交点 1...
Leetcode：链表刷题（7道经典题目）
一起加油~
03-22 1791
Leetcode：链表刷题 列出了一些关于链表的经典题目，并提供了对应的题解。主要是用C++实现的。对于使用其他语言的童鞋，可以很好的迁移过去。
力扣(leetcode)经典题目分享第2期——链表
ZHA_123的博客
11-17 587
本期博客主要讲解的题目是有关链表的一些经典OJ题，有一定难度，希望大家耐心看完。大家加油！
LeetCode和牛客网经典链表题目合集
m0_70811813的博客
11-17 574
移除链表元素、反转链表、链表的中点节点、链表中倒数最后k个节点、合并两个有序链表、分割链表、链表的回文结构、相交链表、环形链表、环形链表II、复制带随机指针的链表
链表问题
陈子龙的博客
07-25 268
链表问题： 涉及头节点的需要设计虚拟头节点来完成 //删除链表的倒数第N个节点,采用两个指针来完成判断 /** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode() : val(0), next(nullptr) {} * ListNode(int x) : val(x), next(nullptr) {} *
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值