leetcode刷题之链表

最新推荐文章于 2022-12-21 18:39:37 发布
最新推荐文章于 2022-12-21 18:39:37 发布
阅读量295 收藏
点赞数
分类专栏： 数据结构和算法 文章标签： 数据结构 leetcode 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39621037/article/details/102615805
版权
合并两个有序链表

在这里插入图片描述

参考代码
普通解法
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
        ListNode* newHead=new ListNode(0);
        ListNode* pre=newHead;
        while(l1&&l2){
            if(l1->val<=l2->val){
                pre->next=l1;
                pre=l1;
                l1=l1->next;
            }else{
                pre->next=l2;
                pre=l2;
                l2=l2->next;
            }
        }
        if(l1) pre->next=l1;
        if(l2) pre->next=l2;
        return newHead->next;
    }
};
递归解法
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
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;
        }else{
            l2->next=mergeTwoLists(l1,l2->next);
            return l2;
        }
    }
};
删除链表的倒数第N个节点(LeetCode.17)

在这里插入图片描述

参考代码
递归解法
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    int count=0;
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        if(head==NULL){
            return NULL;
        }
        head->next=removeNthFromEnd(head->next,n);
        count++;
        if(count==n){
            return head->next;
        }else{
            return head;
        }
    }
};
双指针解法
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        ListNode* tempNode=new ListNode(0);
        tempNode->next=head;
        ListNode* p=tempNode;
        ListNode* q=tempNode;
        for(int i=0;i<n+1;i++)
            q=q->next;
        while(q){
            p=p->next;
            q=q->next;
        }
        
        ListNode* delNode=p->next;
        p->next=delNode->next;
        delete delNode;
        
        ListNode* retNode=tempNode->next;
        delete tempNode;
        
        return retNode;
    }
};
环形链表

在这里插入图片描述

参考代码
/**
 * 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) {
        if(head==NULL) return false;
        ListNode* p=head;
        ListNode* q=head->next;
        while(p!=q){
            if(p==NULL||q==NULL||q->next==NULL)
                return false;
            p=p->next;//慢指针
            q=q->next->next;//快指针
        }
        return true;
    }
};
回文链表

在这里插入图片描述

参考代码
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    bool isPalindrome(ListNode* head) {
        if(head==NULL||head->next==NULL) return true;
        ListNode* fast=head->next;
        ListNode* slow=head;
        ListNode* q=NULL,*p;
        //找到中点,并反转前半部分链表
        while(fast&&fast->next){
            fast=fast->next->next;
            p=slow->next;
            slow->next=q;
            q=slow;
            slow=p;
        }
        //将slow的next指针反转
        p=slow->next;
        slow->next=q;
        //如果是链表长度为奇数
        q=(fast==NULL?slow->next:slow);//若是奇数则fast指向NULL
        //判断是否是回文串
        while(p){
            if(q->val!=p->val) return false;
            q=q->next;
            p=p->next;
        }
        return true;
    }
};
旋转链表

在这里插入图片描述

参考代码
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* rotateRight(ListNode* head, int k) {
        if(head==NULL||head->next==NULL||k==0) return head;
        //先将链表连成环,同时计算链表的长度
        ListNode* tail=head;
        int n=1;
        while(tail->next){
            tail=tail->next;
            n++;
        }
        tail->next=head;
        //找到新的链表尾和链表头
        //新的链表尾在第n-k%n-1个位置
        ListNode* newTail=head;
        for(int i=0;i<n-k%n-1;i++){
            newTail=newTail->next;
        }
        ListNode* newHead=newTail->next;
        newTail->next=NULL;
        return newHead;
    }
};
删除排序链表中的重复元素

在这里插入图片描述

参考代码
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    bool isLeagel(ListNode* pre,ListNode* cur,ListNode* next){
        if((pre&&pre->val==cur->val)||(next&&next->val==cur->val))
            return false;
        return true;
    }
    ListNode* deleteHelper(ListNode* pre,ListNode* head){
        if(head==NULL){
            return NULL;
        }
        ListNode* nextNode=head->next;
        if(isLeagel(pre,head,nextNode)){
            head->next=deleteHelper(head,nextNode);
            return head;
        }else{
            return deleteHelper(head,nextNode);
        }
    }
    ListNode* deleteDuplicates(ListNode* head) {
        return deleteHelper(NULL,head);
    }
};
有序链表转换二叉搜素树

在这里插入图片描述

参考代码
递归解法
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    TreeNode* buildTree(ListNode* head,ListNode* tail){
        if(head==tail) return NULL;
        //找到当前链表的中点
        ListNode* slow=head;
        ListNode* fast=head->next;
        while(fast&&fast!=tail&&fast->next&&fast->next!=tail){
            slow=slow->next;
            fast=fast->next->next;
        }
        TreeNode* newNode=new TreeNode(slow->val);
        newNode->left=buildTree(head,slow);
        newNode->right=buildTree(slow->next,tail);
        return newNode;
    }
    TreeNode* sortedListToBST(ListNode* head) {
        return buildTree(head,NULL);
    }
};

时间复杂度为O(nlogn),空间复杂度为O(logn)

空间换时间解法
//先将链表数据存储在数组中，从而取中间元素的时间复杂度降低为O(1),从而可以将时间复杂度降低为O(n),而空间复杂度升为(O(n))
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    vector<int> a;
    void getA(ListNode* head){
        while(head){
            a.push_back(head->val);
            head=head->next;
        }
    }
    TreeNode* buildTree(int left,int right){
        if(left>right) return NULL;
        int mid=(left+right)/2;
        TreeNode* newNode=new TreeNode(a[mid]);
        if(left==right) return newNode;
        newNode->left=buildTree(left,mid-1);
        newNode->right=buildTree(mid+1,right);
        return newNode;
    }
    TreeNode* sortedListToBST(ListNode* head) {
        getA(head);
        return buildTree(0,a.size()-1);
    }
};
环形链表

在这里插入图片描述

参考代码

使用Floyd算法:
1.利用快慢指针找到交点(注意这里的快慢指针要相同)，若无环则直接返回NULL；
2.定义原起点为p1,交点为p2,p1,p2同时向前移动，每次移动一步，则再次相交处就是环的入口

/**
 * 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==NULL) return NULL;
        ListNode* slow=head;
        ListNode* fast=head;
        do{
            if(fast->next==NULL||fast->next->next==NULL)
                return NULL;
            slow=slow->next;
            fast=fast->next->next;
        }while(slow!=fast);
        ListNode* p1=head;
        ListNode* p2=slow;
        while(p1!=p2){
            p1=p1->next;
            p2=p2->next;
        }
        return p1;
    }
};
对链表进行插入排序

在这里插入图片描述

参考代码
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* insertionSortList(ListNode* head) {
        if(head==NULL||head->next==NULL) return head;
        //为了方便移动链表，在比较的同时反转链表
        ListNode* q=NULL;
        ListNode* p=head;
        ListNode* nextNode=head;
        while(nextNode){
            nextNode=p->next;
            p->next=q;
            q=p;
            //比较，移动节点
            ListNode* pre=p->next;
            int tempVal=p->val;
            while(pre&&pre->val<tempVal){
                p->val=pre->val;
                p=pre;
                pre=pre->next;
            }
            p->val=tempVal;
            p=nextNode;
        }
        return q;
    }
};
排序链表

在这里插入图片描述

解题思路

在这里插入图片描述

参考代码
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    //将链表的前n个节点切割出去，返回下一段的第一个节点
    ListNode* cut(ListNode* head,int n){
        ListNode* p=head;
        while(--n&&p){
            p=p->next;
        }
        if(!p) return NULL;
        ListNode* nextNode=p->next;
        p->next=NULL;
        return nextNode;
    }
    //将两个链表合并
    ListNode* merge(ListNode* head1,ListNode* head2){
        ListNode* newHead=new ListNode(0);
        ListNode* p=newHead;
        while(head1&&head2){
            if(head1->val<head2->val){
                p->next=head1;
                p=head1;
                head1=head1->next;
            }else{
                p->next=head2;
                p=head2;
                head2=head2->next;
            }
        }
        if(head1) p->next=head1;
        if(head2) p->next=head2;
        return newHead->next;
    }
    ListNode* sortList(ListNode* head) {
        if(head==NULL||head->next==NULL) return head;
        //计算链表长度
        int len=0;
        ListNode* p=head;
        while(p){
            len++;
            p=p->next;
        }
        ListNode* dummyHead=new ListNode(0);
        dummyHead->next=head;
        ListNode* tail=dummyHead;
        ListNode* cur=head,*left,*right;
        for(int step=1;step<len;step*=2){
            while(cur){
                left=cur;
                right=cut(left,step);
                cur=cut(right,step);
                tail->next=merge(left,right);
                while(tail->next) tail=tail->next;
            }
            cur=dummyHead->next;
            tail=dummyHead;
        }
        return dummyHead->next;
    }
};

熟记cut(node,n)的写法

总结

1.快慢指针：

  • 删除倒数第几个节点
  • 判断链表中是否有环
  • 找中点

2.递归

  • 通常用于对链表的遍历，比如删除满足特定条件的节点

3.链表的反转，链表的cut(node,n)操作，两个链表的合并等操作要熟记

lingqing97
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
LeetCode刷题模板.pdf
04-05
1.4. LeetCode中二分查找题目 29 2. 双指针 30 2.1. 快慢指针 31 2.1.1. 什么是快慢指针 31 2.1.2. 快慢指针模板 31 2.1.3. 快慢指针相关题目 32 2.1.3.1. LC-141:链表是否有环 32 2.1.3.2. LC-142:环形链表入口 34 ...
LeetCode82 删除排序链表中的重复元素
qq_51553911的博客
04-22 950
Question 给定一个已排序的链表的头 head ， 删除原始链表中所有重复数字的节点，只留下不同的数字 。返回 已排序的链表 。 方法一 当然是递归大法 当head后面有值并且和head的值相等，则一直找到与head不相等为止，然后对后面一个结点去递归，这样就删除了前面重复的结点 当head后面有值且与head的值不相等时，那么就递归后面一个结点，跟在head后面 最后返回head 思路还是很简单的，代码如下： /** * Definition for singly-linked list.
leetcode-链表
Starr
06-17 306
LeetCode-链表 LeetCode 206 - Reverse Linked List - 反转链表 - easy 反转一个单链表。 示例: 输入: 1->2->3->4->5->NULL 输出: 5->4->3->2->1->NULL 进阶: 你可以迭代或递归地反转链表。你能否用两种方法解决这道题？ 三步：备份、更新、移动。 /** * Definition for singly-linked list. * struct ListN
Leetcode题解——数据结构之链表
dieshi8689的博客
06-12 666
1. 找出两个链表的交点 2. 链表反转 3. 归并两个有序的链表 4. 从有序链表中删除重复节点 5. 删除链表的倒数第 n 个节点 6. 交换链表中的相邻结点 7. 链表求和 8. 回文链表 9. 分隔链表 10. 链表元素按奇偶聚集 链表是空节点，或者有一个值和一个指向下一个链表的指针，因此很多链表问题可以用递归来处理。 1. 找出两个链表的交点 1...
LeetCode刷题（23）～反转链表【递归未懂！】
海到无边天作岸 山登绝顶我为峰
08-07 1440
题目描述 反转一个单链表。 示例: 输入: 1->2->3->4->5->NULL 输出: 5->4->3->2->1->NULL 解答 By 海轰 提交代码 /** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x) : val(x), next(NULL)
Leetcode-链表-61. 旋转链表
一只菜鸟夹
03-27 137
题目61. 旋转链表: 题解： 防止K过大，先得把链表长度count算出来，然后进行 k%count才能得到较短的旋转次数 然后保存原链表的尾tail，将其与原来的头连接起来 依据新的k得到新链表的头与尾，做截断与链接 代码： /** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode() : val(0),
LeetCode刷题手册
最新发布
01-16
《LeetCode刷题手册》可能是一本指导如何有效刷题和提升算法编程能力的书籍。以下是可能包含在这本书中的主题： LeetCode介绍： 对LeetCode平台的简要介绍，包括网站功能、题目分类和评估系统。 算法基础： 提供...
leetcode:leetcode刷题记录与总结
04-05
leetcode刷题记录与总结 斑点与矩阵 详细说明 双指针 快慢指针 左右指针 二分查找 滑动窗口 初步和 分治 排序 链表 链表摘要批量操作 单年度查找/操作 树 二叉树前，后，层序等 二叉搜索树中序遍历，二分法等 字典树...
leetcode:开始LeetCode刷题之旅
04-27
密码开始LeetCode刷题之旅列表=====>开始于2015-09-06 <=====反向链表II 重新订购清单k组中的反向节点轮换清单排序清单成对交换节点=====>结束于2015-09-30 <====== 种类=====>从2015-10-08开始<===== 2个...
leetcode-python:leetcode刷题记录
04-12
排序类 ，引申：自然数组排序 重载python sort规则 查找类 （利用部分信息）二分查找，(利用所有... 链表中倒数第k个节点 链表双指针 剑指Offer 24. 反转链表 链表指针 剑指Offer 54. 二叉搜索树的第k大节点 二叉搜
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-16
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){ }
Day3 Linked Lists
赵丽丽的刷题记录！
09-23 236
Day 3 Linked List
LeetCode 解题笔记（四）链表
火山上的企鹅
03-21 745
如果你还不太熟悉链表，下面有关于列表的概要讲述。 有两种常用的列表实现，分别为数组列表和链表。如果我们想在列表中存储值，它们是如何实现的呢？ 数组列表底层是使用数组存储值，我们可以通过索引在 `O(1)` 的时间访问列表任何位置的值，这是由基于内存寻址的方式。 链表 存储的是称为节点的对象，每个节点保存一个值和指向下一个节点的指针。访问某个特定索引的节点需要`O(n)` 的时间，因为要通过指针获取到下一个位置的节点。
python数据结构之链表
weixin_42307828的博客
12-09 344
1.功能实现 链表（Linked list）是一种常见的基础数据结构，是一种线性表，但是并不会按线性的顺序存储数据，而是在每一个节点里存到下一个节点的指针(Pointer)。由于不必须按顺序存储，链表在插入的时候可以达到O(1)的复杂度，比另一种线性表顺序表快得多，但是查找一个节点或者访问特定编号的节点则需要O(n)的时间，而顺序表相应的时间复杂度分别是O(logn)和O(1)。 特点：使用链...
leetcode链表
qq_43283527的博客
04-03 326
例题 2. 两数相加 代码如下： # Definition for singly-linked list. # class ListNode(object): # def __init__(self, x): # self.val = x # self.next = None class Solution(object): def addTwoN...
LeetCode算法之--链表系列
程序大视界
12-21 671
LeetCode链表常见算法题型
LeetCode-题目详解：链表
u013250861的博客
05-13 2182
一、简单题 1、21-合并两个有序链表 将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。 示例 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
链表问题
陈子龙的博客
07-25 210
链表问题： 涉及头节点的需要设计虚拟头节点来完成 //删除链表的倒数第N个节点,采用两个指针来完成判断 /** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode() : val(0), next(nullptr) {} * ListNode(int x) : val(x), next(nullptr) {} *
leetcode刷题顺序
07-27
根据引用\[1\]和引用\[2\]的内容，推荐的LeetCode刷题顺序是按照题目类型刷题，优先选择树、链表、二分查找、DFS、BFS、动态规划等常见类型的题目。可以先做2~4道简单题，然后再做中等难度的题目。在选择题目时，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值