【LeetCode刷题】链表篇

已于 2024-09-26 09:49:23 修改
阅读量177 收藏
点赞数 3
分类专栏： 算法学习 算法刷题打卡 文章标签： leetcode 链表 算法
于 2024-09-25 11:58:41 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gdjdjdj/article/details/142519105
版权

203. 移除链表元素

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode removeElements(ListNode head, int val) {
        ListNode myHead=new ListNode(0,head);
        ListNode pre=myHead;
        while(head!=null){
            if(head.val==val){
                pre.next=head.next;
                head=head.next;
            }
            else{
                pre=head;
                head=head.next;
            }
        }
        return myHead.next;
    }
}

707. 设计链表

class Node{
    public int data;
    public Node next;
    public Node(){
        ;
    }
    public Node(int val,Node next){
        this.data=val;
        this.next=next;
    }
}
class MyLinkedList {
    public int size=0;
    public Node head;

    public MyLinkedList() {
        head=new Node(0,null);
        size=0;
    }
    
    public int get(int index) {
        if(index>=size||index<0)return -1;
        Node ptr=head;
        for(int i=0;i<=index;i++){
            ptr=ptr.next;
            
        }
        return ptr.data;
        
    }
    
    public void addAtHead(int val) {
        Node newHead=new Node(val,head.next);
        head.next=newHead;
        size++;
    }
    
    public void addAtTail(int val) {
        Node ptr=head;
        while(ptr.next!=null){
            ptr=ptr.next;
        }
        Node tail=new Node(val,null);
        ptr.next=tail;
        size++;
    }
    
    public void addAtIndex(int index, int val) {
        
        Node pre=head;
        if(index==size){
            addAtTail(val);
            return ;
        }
        if(index>size)return ;
        if(index<0)index=0;

        for(int i=0;i<index;i++){
            pre=pre.next;
        }
        Node node=new Node(val,pre.next);
        pre.next=node;
        size++;
        
    }
    
    public void deleteAtIndex(int index) {
        if(index>=size)return;
        Node pre=head;
        for(int i=0;i<index;i++){
            pre=pre.next;
        }
        pre.next=pre.next.next;
        size--;
    }
}

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

206.反转链表

思路一：顺序遍历原有链表，使用头插法建立新链表即为反转后的链表。时间复杂度O（n）空间复杂度也为O（n）

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode reverseList(ListNode head) {
        ListNode newhead=new ListNode(0,null);
        ListNode ptr=newhead;
        while(head!=null){
            ptr=head;
            head=head.next;
            ptr.next=newhead.next;
            newhead.next=ptr;
        }
        
        return newhead.next;
    }
}

思路二：原地翻转，ptr用于遍历链表，pre指向在原链表中的前驱，temp用于存储ptr的后驱，最后pre所指就是反转后的头节点

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode reverseList(ListNode head) {
        ListNode pre=null;
        ListNode ptr=head;
        ListNode temp;
        while(ptr!=null){
            temp=ptr.next;
            ptr.next=pre;
            pre=ptr;
            ptr=temp;
        }
        return pre;
    }
}

24.两两交换链表的节点

思路：递归算法，首先确定出口，当链表为空或者只有一个节点时直接返回。将前两个之后的链表作为一个新链表进行递归处理，然后将前两个节点交换。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode swapPairs(ListNode head) {
        if(head==null||head.next==null)return head;
        ListNode next=head.next;
        ListNode newNode = swapPairs(next.next);
        head.next=newNode;
        next.next=head;
        return next;
    }
}

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

思路：这个题的思路还是很巧妙的，利用双指针确定好距离，用距离为n的双指针同时向后遍历，当快指针指向尾节点时，slow恰好指向倒数第n个节点。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {
        ListNode myHead=new ListNode(0,head);
        ListNode fast=head;
        ListNode slow=head;
        ListNode pre=myHead;
        for(int i=1;i<n;i++)fast=fast.next;
        while(fast.next!=null){
            fast=fast.next;
            slow=slow.next;
            pre=pre.next;
        }
        pre.next=slow.next;
        return myHead.next;
    }
}

面试题 02.07 . 链表相交

思路：先计算两个链表的长度，如果链表相交的话，两个链表的尾部应该是对齐的，所以我们计算出长度的差值gap，并且将长的链表的指针指向第gap个位置，这样，两个链表同时向后遍历，如果相交，肯定会同时遍历到相交的节点。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        int len1=0,len2=0;
        ListNode ptr1=headA,ptr2=headB;
        while(ptr1!=null){
            len1++;
            ptr1=ptr1.next;
        }
        while(ptr2!=null){
            len2++;
            ptr2=ptr2.next;
        }
        ptr1=headA;
        ptr2=headB;
        if(len1<len2){
            int temp=len1;
            len1=len2;
            len2=temp;

            ptr1=headB;
            ptr2=headA;
        }
        int gap=len1-len2;
        while(gap!=0){
            ptr1=ptr1.next;
            gap--;
        }

        while(ptr1!=null){
            if(ptr1==ptr2){
                return ptr1;
            }
            ptr1=ptr1.next;
            ptr2=ptr2.next;
        }
        return null;

    }
}

142. 环形链表

思路：核心分两步，首先是判断是否存在环。我们快慢指针，fast指针一次走两步，slow指针一次走一步，如果存在环，fast和slow必然会在环内相遇。在确定环之后下一步就是找环的入口。这里需要一步数学证明推导，参考代码随想录。

/**
 * Definition for singly-linked list.
 * class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public ListNode detectCycle(ListNode head) {
        if(head==null)return head;
        ListNode fast=head,slow=head;
        while(fast!=null&&fast.next!=null){
            fast=fast.next.next;
            slow=slow.next;
            if(fast==slow){
                ListNode ptr1=head,ptr2=fast;
                while(ptr1!=ptr2){
                    ptr1=ptr1.next;
                    ptr2=ptr2.next;
                }
                return ptr1;
            }
        }
        return null;
    }
}

总结

刷完这七道链表相关的题目，比较有收获的地方有

1. 虚拟头节点。使用虚拟头节点可以使第一个结点和其他结点的操作方法一致，不用单独处理头节点

2. 对于遍历链表，如果是已知下标，用for循环会比较好。

3. 对于插入和删除操作，需要先找到前驱节点

4. 双指针的应用非常巧妙，可以实现一次遍历解决问题

5. 相交链表和环形链表需要加强记忆

mjh_yylx
关注
专栏目录
Leetcode刷题技巧，看这一篇就够了
weixin_41930359的博客
08-01 1545
1.常看Discussion。我相信很多同学为了刷题量，解开一道题后会迫不及待地点开下一道题。更为甚者，很多同学把刷题的数量作为衡量水平的绝对标准，比如“老师，我在Leetcode刷了500题，您看去面Google有希望吗？”，结果该挂还是挂了。但是，你有没有试过思考其他过解决方案? 这里并不只是说在自己的代码上继续优化，而是点开Discussion, 看看其他人有没有其他的思路，并思考他们的解法和你的有什么不同。也就是说，Discussion也是刷题的一部分。同学们往后可以注意这点，注意分析别人的思路，.
Leetcode刷题方法总结---链表全解
修行的凡人的博客
08-24 1093
Leetcode刷题方法总结---链表全解
关于leetcode刷题详细介绍
热门推荐
智者之家
10-01 9万+
  虽然刷题一直饱受诟病，不过不可否认刷题确实能锻炼我们的编程能力，相信每个认真刷题的人都会有体会。现在提供在线编程评测的平台有很多，比较有名的有 hihocoder，LintCode，以及这里我们关注的 LeetCode。 LeetCode收录了许多互联网公司的算法题目，被称为刷题神器，我虽然早有耳闻，不过却一直没有上面玩过。   据了解，LeetCode 是一个非常棒的 OJ（Online J...
Leetcode刷题——链表
weixin_47156261的博客
01-14 472
Leetcode刷题-链表一、链表定义一、Leetcode题目1.移除链表元素 一、链表定义 c++链表节点定义方式： // 单链表 struct ListNode { int val; // 节点上存储的元素 ListNode *next; // 指向下一个节点的指针 ListNode(int x) : val(x), next(NULL) {} // 节点的构造函数 }; 自己定义构造函数初始化节点： ListNode *head=new ListNode(5) 使用默
LeetCode刷题攻略
Jak的博客
08-10 618
分析错误：如果遇到错题，仔细分析错误原因并查找资料进行补充学习。回顾解法：总结解法背后的算法思路及其适用场景，确保知识内化。通过系统性刷题、定期复习、充分利用讨论区和总结错题，可以更有效地提高自己的算法能力和面试准备程度。最重要的是保持持续学习的态度和耐心，不断挑战自我。祝你在 LeetCode 刷题和面试中取得优秀的成绩！如果你还有其他具体问题或需要进一步的帮助，请告诉我！
Leetcode刷题指南
shuaikai的博客
11-18 950
leetcode刷题过程中总结
leetcode刷题——链表篇
qq_43651945的博客
05-11 292
例题1移除链表的指定元素 203. 移除链表元素 - 力扣（LeetCode） (leetcode-cn.com) 头部的处理和后续的处理有不同，所以有两种处理方式； 方式一先处理头部 while(head!=null && head.val==val){ head=head.next; } if(head==null) return head; //头结点为空直接结束 方式二加入一个新的头结点，统一处理 if (head == null) { re
leetcode 刷题指南 & 刷题顺序
qijingpei的博客
07-01 5482
leetcode 刷题指南
leetcode刷题方法&路径
weixin_44163570的博客
05-28 727
一开始刷题的时候不能够随便找个题就来做，应该一段时间专门突击某个专题，如“链表”、“二叉树”等。在刷题的过程中应该自己首先想一想，不要一没有思路就去网上找（这样刷题没有效果），自己思考半天试了一试还是做不出来就去百度。做过的题应该做笔记，反复看就跟高中做题一样，有错题本，反复看才有效果。
leetcode刷题-链表01
emmmmXxxy的博客
04-10 1692
C/C++中定义链表节点的方式// 单链表int val;// 节点上存储的元素// 指向下一个节点的指针ListNode(int x) : val(x), next(NULL) {} // 节点的构造函数// 初始化节点// 也可使用默认构造函数初始化节点python中定义链表节点的方式。
leetcode刷题账号-LeetCode:LeetCode刷题记录(C#)
07-06
这个压缩包文件"LeetCode-master"很可能包含了某个用户在刷题过程中的代码记录或者解决方案。 在刷LeetCode的过程中，有几个关键知识点是值得深入探讨的： 1. **基础数据结构**：在LeetCode的题目中，常见数据结构...
algorithm-learning:leetcode刷题（Java，Python）和算法书籍
03-18
《algorithm-learning: leetcode刷题（Java，Python）和算法书籍》这个压缩包文件主要包含的是关于算法学习的资源，特别是针对LeetCode平台上的题目进行的编程实践，涉及的编程语言主要是Java和Python。LeetCode是一...
LeetCode刷题笔记.rar
07-05
《LeetCode刷题笔记》是针对LeetCode这个在线编程挑战平台的个人学习心得与总结，主要涵盖数据结构和算法两大核心领域。LeetCode是一个全球知名的编程训练网站，它提供了丰富的编程题目，帮助开发者提升编程技能，...
LeetCode 刷题笔记 with Java.zip
11-23
《LeetCode刷题笔记withJava》是一份专为Java开发者准备的算法实战指南，涵盖了LeetCode网站上前一百道编程挑战题目。这份资料旨在帮助程序员提升算法能力，掌握数据结构和问题解决技巧，对于准备面试或者想要提升...
1_leetcode刷题指南.pdf
05-08
本文件为《1_leetcode刷题指南.pdf》的内容摘录，它是一份关于在leetcode上进行编程刷题的分组指南。leetcode是一个提供编程题目和在线评测系统的平台，广泛用于计算机科学和软件工程领域的算法和编程技能训练。根据...
力扣 困难 154.寻找旋转排序数组中的最小值 II
qq_51352130的博客
09-23 386
153.寻找旋转排序数组中的最小值在此基础上，进行二分之前，单独处理一下左指针和最后一个数相同的情况就好了。left++;} else {
leetcode226. 翻转二叉树
最新发布
Turboyiyi的博客
09-27 126
递归翻转二叉树
[leetcode]113_路径总和II_输出所有路径
weixin_45653183的博客
09-24 392
leetcode 的 Python 代码——处理输入输出；仅记录便于以后自查自学使用
C++速通LeetCode中等第25题-验证二叉搜索树（中序遍历堆栈迭代法）
lyx的博客
09-23 258
中序遍历堆栈迭代法
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值