leetcode(链表专题)

最新推荐文章于 2024-09-18 11:04:20 发布
最新推荐文章于 2024-09-18 11:04:20 发布
阅读量758 收藏
点赞数 1
分类专栏： 笔记 文章标签： 链表 leetcode 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_46517733/article/details/121265052
版权
这篇博客介绍了链表的基础知识和常见编程题，包括链表的删除元素、反转链表、设计链表类、寻找链表相交点、环形链表的检测和环的入口、以及删除链表中间节点的方法。涉及递归、迭代等多种解题策略，是链表操作的实用指南。
摘要由CSDN通过智能技术生成

链表

1.导论

  • 链表分类：单链表、双向链表、循环链表
  • 链表考查点：

链表的增删改查
虚拟头结点
链表反转
链表相交
是否有环
如果有环，环的入口

2.编程题

2.1 203.移除链表元素

给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == val 的节点，并返回 新的头节点 。
列表中的节点数目在范围 [0, 104] 内
1 <= Node.val <= 50
0 <= val <= 50

/**
 * 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) {
        if (head == null) {
            return head;
        }
        head.next = removeElements(head.next, val);
        return head.val == val ? head.next : head;
    }
}

//迭代
class Solution {
    public ListNode removeElements(ListNode head, int val) {
       /*
            思路：
                1.创建一个前置头节点
                2.循环遍历链表，如果节点值和val相等，进行删除，否则继续遍历
                3.返回新链表的头节点
        */
        ListNode preHead = new ListNode(-1);
        preHead.next = head;
        ListNode cur = preHead;
        while(cur.next != null){
            if(cur.next.val == val){
                cur.next = cur.next.next;
            }else{
                cur = cur.next;
            }
        }
        return preHead.next;
    }
}

2.2 707.设计链表

设计链表的实现。您可以选择使用单链表或双链表。单链表中的节点应该具有两个属性：val 和 next。val 是当前节点的值，next 是指向下一个节点的指针/引用。如果要使用双向链表，则还需要一个属性 prev 以指示链表中的上一个节点。假设链表中的所有节点都是 0-index 的。

在链表类中实现这些功能：

get(index)：获取链表中第 index 个节点的值。如果索引无效，则返回-1。
addAtHead(val)：在链表的第一个元素之前添加一个值为 val 的节点。插入后，新节点将成为链表的第一个节点。
addAtTail(val)：将值为 val 的节点追加到链表的最后一个元素。
addAtIndex(index,val)：在链表中的第 index 个节点之前添加值为 val 的节点。如果 index 等于链表的长度，则该节点将附加到链表的末尾。如果 index 大于链表长度，则不会插入节点。如果index小于0，则在头部插入节点。
deleteAtIndex(index)：如果索引 index 有效，则删除链表中的第 index 个节点。

所有val值都在 [1, 1000] 之内。
操作次数将在 [1, 1000] 之内。
请不要使用内置的 LinkedList 库

//节点类
public class ListNode {
  int val;
  ListNode next;
  ListNode(int x) { val = x; }
}


class MyLinkedList {
    int size;//记录链表的长度
    ListNode head;
    public MyLinkedList() {
        this.size = 0;
        this.head = new ListNode(0);
    }
    
    public int get(int index) {
        if(index < 0 || index>=size) return -1;
        ListNode cur = head;
        for(int i=0;i<=index;++i){
            cur = cur.next;
        }
        return cur.val;
    }
    
    public void addAtHead(int val) {
        addAtIndex(0,val);
    }
    
    public void addAtTail(int val) {
        addAtIndex(size,val);
    }
    
    public void addAtIndex(int index, int val) {
        if(index > size) return;

        if(index < 0) index = 0;

        ++size;
        ListNode dummy = new ListNode(-1);
        dummy = head;
        ListNode cur = dummy;
        for(int i=0;i<index;++i){
            cur = cur.next;
        }
        ListNode temp = cur.next;
        ListNode newNode = new ListNode(val);
        cur.next = newNode;
        newNode.next = temp;

    }
    
    public void deleteAtIndex(int index) {
        if(index <0 || index >=size) return;
        size--;
        ListNode dummy = new ListNode(-1);
        dummy = head;
        ListNode cur = dummy;
        for(int i=0;i<index;++i){
            cur = cur.next;
        }
        cur.next = cur.next.next;
    }
}

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

2.3 203.反转链表

给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。

链表中节点的数目范围是 [0, 5000]
-5000 <= Node.val <= 5000

/**
 * 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) {
        if(head == null || head.next == null){
            return head;
        }
        ListNode newHead = reverseList(head.next);
        head.next.next = head;
        head.next = null;
        return newHead;
    }
}

//迭代
class Solution {
    public ListNode reverseList(ListNode head) {
        if(head == null || head.next == null){
            return head;
        }
        ListNode cur = head;
        ListNode next = null;
        ListNode reverseNode = new ListNode(-1);
        while(cur != null){
            next = cur.next; //先保存当前结点的下一个结点，后面需要使用
            cur.next = reverseNode.next;//将cur的下一个结点指向新的链表的最前端
            reverseNode.next = cur;//将cur链接到新的链表上
            cur = next;//让cur后移
        }
        return reverseNode.next;//返回头指针0
    }
}

2.4 19.删除链表的倒数第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 dummy = new ListNode(0,head);
        Deque<ListNode> stack = new LinkedList<ListNode>();
        ListNode cur = dummy;
        while(cur != null){
            stack.push(cur);
            cur  = cur.next;
        }
        while(n-- > 0){
            stack.pop();
        }
        ListNode pre = stack.peek();
        pre.next = pre.next.next;
        return dummy.next;
    }
}
//使用双指针
class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {
        ListNode  dummy = new ListNode(0,head);
        ListNode first = head;
        ListNode second = dummy;
        for(int i=0;i<n;++i){
            first = first.next;
        }
        while(first != null){
            first = first.next;
            second = second.next;
        }
        second.next = second.next.next;
        return dummy.next;
    }
}

//计算链表长度
class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {
        ListNode dummy = new ListNode(0, head);
        int length = getLength(head);
        ListNode cur = dummy;
        for (int i = 1; i < length - n + 1; ++i) {
            cur = cur.next;
        }
        cur.next = cur.next.next;
        ListNode ans = dummy.next;
        return ans;
    }

    public int getLength(ListNode head) {
        int length = 0;
        while (head != null) {
            ++length;
            head = head.next;
        }
        return length;
    }
}

2.5 160.相交链表

给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表没有交点，返回 null 。

listA 中节点数目为 m
listB 中节点数目为 n
0 <= m, n <= 3 * 104
1 <= Node.val <= 105
0 <= skipA <= m
0 <= skipB <= n
如果 listA 和 listB 没有交点，intersectVal 为 0
如果 listA 和 listB 有交点，intersectVal == listA[skipA + 1] == listB[skipB + 1]

/**
 * 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) {
        if(headA == null || headB == null){
            return null;
        }
        ListNode cur = headA;
        Set<ListNode> set = new HashSet();
        while(cur != null){
            set.add(cur);
            cur= cur.next;
        }
        cur = headB;
        while(cur != null){
            if(!set.add(cur)){
                return cur;
            }
            cur=cur.next;
        }
        return null;

    }
}

//双指针
public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        if(headA == null || headB == null){
            return null;
        }
        ListNode curA = headA;
        ListNode curB = headB;
        while(curA != curB){
            curA = curA==null ? headB : curA.next;
            curB = curB == null ? headA : curB.next;
        }
        return curA;
    }
}

2.6 141.环形链表

给定一个链表，判断链表中是否有环。

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

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

链表中节点的数目范围是 [0, 104]
-105 <= Node.val <= 105
pos 为 -1 或者链表中的一个 有效索引

/**
 * Definition for singly-linked list.
 * class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
 //哈希集合
public class Solution {
    public boolean hasCycle(ListNode head) {
        Set<ListNode> visited = new HashSet<ListNode>();
        while(head != null){
            if(!visited.add(head)){
                return true;
            }
            head = head.next;
        }
        return false;
    }
}
//快慢指针
public class Solution {
    public boolean hasCycle(ListNode head) {
        if(head == null || head.next == null){
            return false;
        }
        ListNode slow = head;
        ListNode fast = head.next;
        while(slow != fast){
            if(fast == null || fast.next == null){
                return false;
            }
            slow = slow.next;
            fast = fast.next.next;
        }
        return true;
    }
}

2.7 142.环形链表II

给定一个链表，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。

为了表示给定链表中的环，我们使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。 如果 pos 是 -1，则在该链表中没有环。注意，pos 仅仅是用于标识环的情况，并不会作为参数传递到函数中。

说明：不允许修改给定的链表。

进阶：你是否可以使用 O(1) 空间解决此题？

链表中节点的数目范围在范围 [0, 104] 内
-105 <= Node.val <= 105
pos 的值为 -1 或者链表中的一个有效索引

/**
 * 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) {
        ListNode pos = head;
        Set<ListNode> visited = new HashSet<ListNode>();
        while (pos != null) {
            if (visited.contains(pos)) {
                return pos;
            } else {
                visited.add(pos);
            }
            pos = pos.next;
        }
        return null;
    }
}

//快慢指针
public class Solution {
    public ListNode detectCycle(ListNode head) {
        if(head == null || head.next == null){
            return null;
        }
        ListNode slow = head;
        ListNode fast = head;
        while(fast != null && fast.next != null){
            slow = slow.next;
            fast = fast.next.next;
            if(slow == fast){//说明有环
                ListNode temp = head;
                while(slow != temp){//temp和slow相遇的结点就是环的入口
                    slow = slow.next;
                    temp = temp.next;
                }
                return temp;
            }
        }
        return null;
    }
}

2.8 2095. 删除链表的中间节点

给你一个链表的头节点 head 。删除 链表的 中间节点 ，并返回修改后的链表的头节点 head 。

长度为 n 链表的中间节点是从头数起第 ⌊n / 2⌋ 个节点（下标从 0 开始），其中 ⌊x⌋ 表示小于或等于 x 的最大整数。

对于 n = 1、2、3、4 和 5 的情况，中间节点的下标分别是 0、1、1、2 和 2 。
链表中节点的数目在范围 [1, 105] 内
1 <= Node.val <= 105

/**
 * 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; }
 * }
 */
//shuangzhizhen 
class Solution {
    public ListNode deleteMiddle(ListNode head) {
        if(head == null || head.next == null) return null;
        ListNode slow = head;
        ListNode fast = head.next.next;
        while(fast != null && fast.next != null){
            slow = slow.next;
            fast = fast.next.next;
        }
        slow.next = slow.next.next;
        return head;
    }
}

/**
 * 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 deleteMiddle(ListNode head) {
        ListNode dummy = new ListNode(-1);//设置前驱结点
        dummy.next = head;
        ListNode cur = dummy;
        int length = getLength(head);
        for(int i=0;i<length/2;++i){
            cur = cur.next;//查找中间结点的前一个结点
        }
        cur.next = cur.next.next;
        return dummy.next;
    }
    //计算链表长度
    private int getLength(ListNode head){
        int length = 0;
        while(head != null){
            head = head.next;
            ++length;
        }
        return length;
    }
    
}
Listen·Rain
关注
专栏目录
【LeetCode系列】【链表专题】
qq_36417014的博客
10-24 510
目录 专题二：链表 LeetCode 19 删除链表的倒数第N个节点 1、分析 2、 代码 LeetCode 237 删除链表中的节点 1、分析 2、代码 LeetCode 83 删除排序链表中的重复元素 1、分析 2、代码 LeetCode 61 旋转链表 1、分析 2、代码 LeetCode 24 两两交换链表中的节点 1、分析 2、代码 LeetCode 2...
Leetcode刷题方法总结---链表全解
修行的凡人的博客
08-24 1081
Leetcode刷题方法总结---链表全解
【链表】经典链表题LeetCode
鹏啊鹏
08-13 689
LeetCode经典链表题
leetcode刷题——链表
xxp的博客
03-12 319
leetcode刷题——链表
LeetCode算法之--链表系列
程序大视界
12-21 920
LeetCode链表常见算法题型
LeetCode分类刷题----链表篇
池鱼
01-12 1250
设立两个快慢指针，先让快指针走n+步，当快指针指向链表尾节点的时候，此时慢指针恰好走到要删除节点的前一个节点，此时对慢指针进行删除即可。设头节点到成环节点的距离为x，设成环节点到相遇节点的距离为y，设相遇节点到成环节点的距离为z。给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == val 的节点，并返回 新的头节点。两个指针，当着两个指针走向尽头时，然后转向另一个链表的头节点，直到这两个链表相遇，因为这两个节点都走了同样的长度。当n=1的时候有x=z。
【LeetCode】链表专题
Arthur的博客
06-19 170
LeetCode链表专题
数据结构与算法（Leetcode链表篇）
m0_52427988的博客
07-30 505
Leetcode链表问题2，19，21，24，61，82.
leetcode递归专题-leetcode:不定期发布leetcode解题思路和代码
06-30
leetcode递归专题 leetcode 我的LeetCode主页： 不定期发布leetcode解题思路和代码 一些好的题目 动态规划 一般dp 区间dp 位数dp 状压dp 树形DP 树 二叉树 前缀树 -- 其他树上问题 ---- ---- ---- ---- ---- ---- --...
leetcode递归专题-Leetcode-Solutions:包含LeetCode问题的解决方案TopicWise
06-30
递归专题Leetcode-解决方案 包含 LeetCode 问题的解决方案 TopicWise 描述 repo 中的每个文件夹对应 Leetcode 上的每个 Each Topic。 此外，每个文件夹包含 3 个子文件夹作为难度级别 Viz。 容易，中等，困难。 话题...
LeetCode题解：622. 设计循环队列，使用数组，JavaScript，详细注释
Lee Chen的博客
09-16 151
原题链接：https://leetcode-cn.com/problems/design-circular-queue/ 解题思路： 采用两个指针，头指针指向队首，尾指针指向入队元素插入队列的位置，尾指针-1则为队尾。 进行出入队列操作时，头尾指针都加1，注意处理指针移出队列范围时，要循环到队列内部的问题。 /** * Initialize your data structure here. Set the size of the queue to be k. * @param {number} k
LeetCode题解：641. 设计循环双端队列，使用双向链表，JavaScript，详细注释
Lee Chen的博客
09-29 160
原题链接：https://leetcode-cn.com/problems/design-circular-deque/ 解题思路： 如果你看到这题的时候，感到没有思路，可以先尝试其前导题目：622. 设计循环队列，以及我的题解LeetCode题解：622. 设计循环队列，使用双向链表，JavaScript，详细注释。 使用双向链表，每次插入元素时，都创建一个节点，将其连接到链表的头或尾。 删除元素时，值需要将链表头尾节点的连接打断即可。 使用头尾指针，分别指向链表的头尾，用于取值、添加和删除。 使用le
leetcode707:设计链表(增删差)
qq_48508278的博客
01-02 405
一:题目 二:上码 class MyLinkedList { public: //定义链表节点结构体 struct LinkedNode { int val; LinkedNode* next; LinkedNode(int val):val(val), next(nullptr){} }; // 初始化链表 MyLinkedList() { node = new LinkedNode(0); /
Leetcode刷题系列java版-----链表(简单)
qq_39687662的博客
07-21 381
我写的这个系列的博客解题的算法不一定是时间和空间复杂度最优的解,一切以能AC+算法模板普适性为原则解题 首先是链表的增删改查,所有问题都是以链表的增删改查为核心去变种的,改和查按照条件去遍历链表即可,下面直接看leetcode原题: 1.移除链表元素(链表删除节点的模板题) 要点: ①进来一定要先记得判空,在访问next的时候也一定要注意代码是否会造成空指针异常,如果一个类比如ListNode题中的两个属性val和next,如果当前节点node为null,那么访问val和next的时候都会报空指.
数据结构【双链表、Leetcode链表题--4】
我心如火
05-17 1498
双链表：带头双向循环链表，这是最优链表，任意地方插入删除时间复杂度都是O(1)。Leetcode链表刷题
Python世界：力扣29题两数相除算法实践
来知晓的博客
09-13 550
除法运算本质是减法，从理解原理到真正实现还是有距离，建议初步理解后，不参考任何代码，完全自己复现一遍，体会更深。注意提示：目的就是提醒越界问题：-2^31/-1=2&31，超过了整数表达范围。本问题来自于力扣29题，在做完大数相乘后，顺带也看下两数相除。将两数相除，要求不使用乘法、除法和 mod 运算符。给定两个整数，被除数。
C++速通LeetCode中等第3题-盛最多水的容器
最新发布
lyx的博客
09-18 241
双指针法：两个指针分别指向左右边界，记录最大面积，由于面积由短板决定，两个指针中较短的短指针向内移动一格，再次记录最大面积，直到两指针相遇，得出答案。
力扣 16.最接近的三数之和
qq_51352130的博客
09-16 337
设 s=nums[i]+nums[j]+nums[k]，为了判断 s 是不是与 target 最近的数，我们还需要用一个变量 minDiff 维护 ∣s−target∣ 的最小值。分类讨论：如果 s=target，那么答案就是 s，直接返回 s。如果 s>target，那么如果 s−target<minDiff，说明找到了一个与 target 更近的数，更新 minDiff 为 s−target，更新答案为 s。然后和三数之和一样，把 k 减一。
【JavaScript】LeetCode：707设计链表
weixin_45980065的博客
09-14 726
【代码】【JavaScript】LeetCode：707设计链表。
LeetCode链表专题：高效反转策略与递归解法
"LeetCode算法数据结构专训笔记，涵盖了链表、栈、递归等常见数据结构和算法，旨在提升编程能力与解决问题的技巧。笔记详细解释了如何使用不同方法，如头插法和栈，来解决链表反转问题，并通过递归深入理解反转逻辑...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Listen·Rain

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值