关于Java链表的一些操作以及力扣原题刷刷刷——反转链表、删除链表的倒数第N个节点

最新推荐文章于 2024-10-06 20:16:20 发布
最新推荐文章于 2024-10-06 20:16:20 发布
阅读量514 收藏 3
点赞数 13
分类专栏： 算法 文章标签： java 链表 leetcode 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_59435116/article/details/141813413
版权

1、反转链表

1.1 环境准备，可以自己先尝试实现

/**
 * @Author Miku
 * @Date 2024/09/02 09:54
 * @Description TODO
 * @Version 1.0
 */
public class Solution {
    static class ListNode {
        int val;
        ListNode next;

        ListNode(int val) {
            this.val = val;
        }

        ListNode(int val, ListNode next) {
            this.val = val;
            this.next = next;
        }
    }

    public ListNode reverseList(ListNode head) {
        // 补充实现代码

        return null;
    }

    public static void main(String[] args) {
        ListNode head = new ListNode(1, new ListNode(2, new ListNode(3, new ListNode(4, new ListNode(5)))));
        Solution solution = new Solution();
        ListNode result = solution.reverseList(head);
        printList(result);  // 输出：5 -> 4 -> 3 -> 2 -> 1
    }

    private static void printList(ListNode head) {
        while (head != null) {
            System.out.print(head.val);
            head = head.next;
            if (head != null) System.out.print(" -> ");
        }
        System.out.println();
    }

}

1.2 实现思路

在这里插入图片描述
实际我们看到的这个链表并不完整，完整的链表结尾应该有null，我们遍历链表的时候也是判断当前指针是否是null，为null时代表结束了，所以我们补充完整上图得到：
在这里插入图片描述

得到完整之后我们再来想如何反转

a. 了解两个节点之间的关系

如图所示：
反转前：节点1指向节点2
反转后：节点1指向null，节点2指向节点1

现在我们只能操作一个节点，一般都是操作head（头节点），我们需要思考一件事，就是怎么凑齐反转后的那些变量
在这里插入图片描述

首先：head头节点可以看作是节点1，当时null和节点2是我们需要新建的变量，为了方便理解，
我们可以用新变量 cur 来表示当前的节点，即在一开始 ListNode cur = head;
所以我们还需要添加两个变量，分别是 pre（上一个） 和 next（下一个），其中 pre = null，next = cur.next

public ListNode reverseList(ListNode head) {
        // 补充实现代码
        ListNode pre = null;
        ListNode cur = head;
        ListNode next = cur.next;

        return null;
}

b. 扩展一个节点

在这里插入图片描述

如图可以知道，一开始 cur 的上一个节点为null，但是当 cur 为节点2时，他的上一个节点就变成了节点1，
所以 pre 和 next 需要跟着我们的 cur 改变而改变，初始化为 pre，next = cur.next

public ListNode reverseList(ListNode head) {
    // 补充实现代码
    ListNode pre = null;
    ListNode cur = head;
    while(cur != null) {
        // next 需要随着 cur 的变化而变化，所以放循环里面
        ListNode next = cur.next;
        
        // pre 需要随着 cur 的变化而变化，所以也要放循环里面
        pre = cur;
    }
    return null;
}

c. 执行反转操作

在这里插入图片描述

了解上述之后我们就可以来写反转操作了
执行反转操作无非就是将 cur 的下一个指针指向 pre 罢了
（原来指向下一个的变成指向上一个就是反转了）指向下一个就是cur.next，指向上一个前面保存在 pre 了
这一步操作需要在 pre 发生改变之前执行

// 将 cur 的下一个指针指向 pre，这一步操作需要在 pre 发生改变之前执行
cur.next = pre;

反转之后为了让循环继续，把当前指针变为 next ，注意这个应该在前面都完成的基础上最后一步执行

// 反转已经执行完毕了，该转移到下一个节点了，所以是循环的最后一步
cur = next;

完整代码

public ListNode reverseList(ListNode head) {
    // 补充实现代码
    ListNode pre = null;
    ListNode cur = head;
    while (cur != null) {
        // next 需要随着 cur 的变化而变化，所以放循环里面
        ListNode next = cur.next;

        // 将 cur 的下一个指针指向 pre，这一步操作需要在 pre 发生改变之前执行
        cur.next = pre;

        // pre 需要随着 cur 的变化而变化，所以也要放循环里面
        pre = cur;

        // 反转已经执行完毕了，该转移到下一个节点了，所以是循环的最后一步
        cur = next;
    }
    // 这一步纯粹是为了方便理解，形成闭环（大白话就是让我们理解最终 pre 就是 head ，因为 cur 为 null，结合图可理解）
    head = pre;
    return head;
}

在这里插入图片描述

2、删除链表的倒数第N个节点

力扣原题：https://leetcode.cn/problems/remove-nth-node-from-end-of-list/

2.1 环境准备，可以自己先尝试实现

/**
 * @Author Miku
 * @Date 2024/09/02 09:54
 * @Description TODO
 * @Version 1.0
 */
public class Solution {
    static class ListNode {
        int val;
        ListNode next;

        ListNode(int val) {
            this.val = val;
        }

        ListNode(int val, ListNode next) {
            this.val = val;
            this.next = next;
        }
    }

    public ListNode removeNthFromEnd(ListNode head, int n) {
        // 补充实现代码

        return null;
    }

    public static void main(String[] args) {
        ListNode head = new ListNode(1, new ListNode(2, new ListNode(3, new ListNode(4, new ListNode(5)))));
        Solution solution = new Solution();
        ListNode result = solution.removeNthFromEnd(head, 2);
        printList(result);  // 输出：1 -> 2 -> 3 -> 5
    }

    private static void printList(ListNode head) {
        while (head != null) {
            System.out.print(head.val);
            head = head.next;
            if (head != null) System.out.print(" -> ");
        }
        System.out.println();
    }

}

2.2 实现思路

a. 扫描删除

扫描一遍链表，得到总长后，根据计算可以得出要删除的是正向的第几个元素，然后删除即可

// 计算总长度 len
int len = 0;
while(head != null) {
    ++ len;
    head = head.next;
}

在这里插入图片描述

// 遍历到第 n 个元素
for(int i = 1; i < len - n; i ++) {
    head = head.next;
}
// 删除（链表中的删除实际就是将连接的节点跳过一个即可达到删除目的）
head.next = head.next.next;

走到这里应该有兄弟发现有问题了

  1. 前面计算总长度的时候head节点就已经不在原来的位置了，这里的head都在结尾了，根本不能用head从头遍历，我后面还要拿着头指针从头遍历呢~
  2. 如果只有一个节点，然后又要删除倒数第一个，那head.next.next 就是 null.next（空指针异常）

解决：

  1. 添加一个新变量cur = head，然后操作 cur 就好啦，这样就不会影响 节点head
  2. 加一个空值判断就可以避免空指针了
// 保存head，以便返回需要
ListNode ans = head;
 ListNode cur = head;
 int len = 0;
 while(head != null) {
     ++ len;
     head = head.next;
 }
// 使用临时变量遍历
 for(int i = 1; i < len - n; i ++) {
     cur = cur.next;
 }
 if(cur.next != null){
     cur.next = cur.next.next;
 }
 
 return ans;

在这里插入图片描述
一执行发现当只有一个元素的时候出错了
错误原因：删除第一个元素的时候，由于我们是从head开始的，所以没办法跳过head这个元素。
解决方案：我们新添加一个助力节点（官方叫哑节点dummy），使用一个节点帮忙后我们既可以通过它跳过head元素，也可以避免空指针现象

// 助力节点，指向头指针
ListNode dummy = new ListNode(0, head);
// 从助力节点开始遍历，避免空指针
ListNode cur = dummy;
int len = 0;
while(head != null) {
    ++ len;
    head = head.next;
}
// 因为多了助力节点，所以要 + 1（加的就是助力节点）
for(int i = 1; i < len - n + 1; i ++) {
    cur = cur.next;
}
// 多了助力节点，不会报空啦
cur.next = cur.next.next;
return dummy.next;

在这里插入图片描述

完整代码：

/**
 * @Author Miku
 * @Date 2024/09/02 09:54
 * @Description TODO
 * @Version 1.0
 */
public class Solution {
    static class ListNode {
        int val;
        ListNode next;

        ListNode(int val) {
            this.val = val;
        }

        ListNode(int val, ListNode next) {
            this.val = val;
            this.next = next;
        }
    }

    public ListNode removeNthFromEnd(ListNode head, int n) {
        // 补充实现代码
        ListNode dummy = new ListNode(0, head);
        ListNode cur = dummy;
        int len = 0;
        while(head != null) {
            ++ len;
            head = head.next;
        }

        for(int i = 1; i < len - n + 1; i ++) {
            cur = cur.next;
        }
        cur.next = cur.next.next;
        return dummy.next;
    }

    public static void main(String[] args) {
        ListNode head = new ListNode(1, new ListNode(2, new ListNode(3, new ListNode(4, new ListNode(5)))));
        Solution solution = new Solution();
        ListNode result = solution.removeNthFromEnd(head, 2);
        printList(result);  // 输出：1 -> 2 -> 3 -> 5
    }

    private static void printList(ListNode head) {
        while (head != null) {
            System.out.print(head.val);
            head = head.next;
            if (head != null) System.out.print(" -> ");
        }
        System.out.println();
    }
}
墨崇M柒
关注
专栏目录
python【力扣LeetCode算法题库】19-删除链表的倒数第N个节点
01-21
删除链表的倒数第N个节点 给定一个链表，删除链表的倒数第 n 个节点，并且返回链表的头结点。 示例： 给定一个链表: 1->2->3->4->5, 和 n = 2. 当删除了倒数第二个节点后，链表变为 1->2->3->5. 说明： 给定的 n ...
Java输出链表倒数第k个节点
08-29
Java输出链表倒数第k个节点 在Java编程中，输出链表倒数第k个节点是一个常见的问题，本文将为大家介绍三种不同的设计思路及代码示例，旨在帮助需要的朋友更好地理解和解决这个问题。 思路1：计算链表长度 第一种...
链表---Leetcode刷刷刷
如果可以一直带着少年时的酷
12-04 76
等，将所有情况考虑进去。
LeetCode刷题——链表OJ（历时三天，万字博客，十一道经典题，带你手撕链表）
yakiyakiya的博客
09-11 1081
删除结点、反转链表、环形链表、复制链表、找中间结点和第k个结点、回文链表、相交结点、分割链表、合并两个链表。万字博客，手撕链表！！初学者一定要点进来看看！！！学完以后一定能让你对链表的理解更上一层楼！！全网最详细！！
c++刷算法【链表】
m0_52712579的博客
03-08 614
温习数据结构与算法，准备一些比赛，为了学业和就业，以及提升自己的编程能力，将系统的刷刷算法，入手c++跟着carl，leetcode刷题笔记将持续更新… 链表 定义链表节点方式，如下所示： // 单链表 struct ListNode { int val; // 节点上存储的元素 ListNode *next; // 指向下一个节点的指针 ListNode(int x) : val(x), next(NULL) {} // 节点的构造函数 }; 通过自己定义构造函数初始化节点
算法系列之链表
Web分享
02-09 200
链表和数组有点类似，都是线性表的一种，但是它们又有很大的不同。数组需要一块连续的内存空间来存储，而链表恰恰相反，它并不需要一块连续的内存空间，它通过“指针”将一组零散的内存块串联起来使用。
力扣题单(小白友好)
m0_70094411的博客
03-19 1310
力扣题单(小白友好)
刷穿leetcode之链表总结(1)
qq_45518377的博客
01-01 861
那要介绍一下跟它比较类似的一种存储结构，线性表(数组)，数组的存储方式都是一段线性内存的存储，如果要对数组进行添加元素什么的，非常麻烦！但是链表其在内存中不是线性存储的，而是乱序存储的，只需要在每个节点中将附近的节点的地址存储在其相应的指针域。从这个图就可以看出来，我的代码head指向的头节点(为要删除的元素)，那么cur去删除了之后，head就会指向空了，head这个指针就会变成悬浮指针。最开始总结的是链表，链表是数据结构十分基础的一个概念，它的类型有几种，分别是单链表，双链表，环形链表。
双指针算法大总结！！看完这篇文章再也没有难的双指针题！！例题C++解法！
weixin_45962681的博客
07-31 1263
题源acwing、力扣讲解双指针题目一：盛最多水的容器思路AC代码题目二：查找总价格为目标值的两个商品思路AC代码题目三：链表的中间节点思路AC代码题目四：环形链表思路AC代码题目五：反转字符串中的元音字符思路AC代码题目六：最长连续不重复子序列思路AC代码题目七：判断子序列思路AC代码 讲解双指针 使用双指针是降低算法复杂度的一个有效途径，有些问题的暴力解法时间O(n2)，但是使用双指针可以大幅度降低算法复杂度。 和贪心算法一样，双指针难在想不到 常用的双指针法有以下几类： 左右指针：两个指针，相向而走，
1024程序员节推荐书--《剑指Offer》专题突破版
宇宙之一粟的技术漂泊之旅
10-24 3329
《剑指Offer》书评 众所周知，在互联网招聘中，总少不了笔试这一环节。而说到笔试，肯定有一本书会被每一个童鞋提及——那就是《剑指Offer》，在更新了两版后，终于在2021年的夏天这本书也更新了——《剑指Offer》专题突破版。 第一时间拿到这本书后已经开始慢慢阅读起来了。刚好去年也在校招前买了之前的版本，说一下我拿到这本第一感受就是何海涛大佬更用心了。如书名的副标题——专项突破，专题大概可分为两大块：数据结构 + 算法。 可千万别觉得数据结构和算法就此分开了，其实算法的解题套路也是需要一个个数据结构中
算法入坑训练
mrbone9的博客
01-03 412
算法入坑 自我刷题
java-leetcode题解之第19题删除链表的倒数第N个结点.zip
06-17
本题解集中于LeetCode的第19题，即“删除链表的倒数第N个节点”。这道题目主要涉及链表操作，特别是涉及到链表的遍历和节点删除，是链表数据结构的基础应用之一。 首先，我们需要理解链表的基本概念。链表是一种...
LeetCode刷题笔记——19. 删除链表的倒数第N个节点
12-21
给定一个单链表的头节点`head`和一个整数`n`，你需要删除链表中倒数第`n`个节点，并返回调整后的链表头节点。 ### 解题分析： #### 1. 单指针两次遍历法： 首先遍历整个链表，计算链表的长度`length`，然后再次...
java面试-leetcode面试题解之第19题删除链表的倒数第N个结点.zip
03-09
第19题，删除链表的倒数第N个节点，是一个典型的链表操作问题，对于求职者来说，掌握这类问题的解决方案至关重要。这道题目旨在考察候选人对链表的基本操作、指针技巧以及对数据结构的理解。 首先，我们需要了解...
JDK1.0主要特性
最新发布
FoolRabbit的专栏
10-06 278
JDK1.0主要特性。
JavaScript ArrayBuffer的读写与类型转换
白瑕 的博客
10-01 485
所有视图的基本单位是ArrayBuffer, ArrayBuffer中只存储二进制格式的数据.ArrayBuffer不可直接读写, 必须通过视图(比如DataView)暴露的API.
Java内存布局
阿呆的专栏
10-01 822
64位 JVM 不启用指针压缩时：Object Header 大小是16字节。64位 JVM 启用指针压缩时（默认）：Object Header 大小是12字节。32位 JVM：Object Header 大小是8字节。JVM在默认情况下启用指针压缩，但如果堆内存超过32GB，就会禁用指针压缩。32GB是压缩指针的最大寻址范围。超过32GB的堆内存中，压缩指针带来的性能提升并不显著，而且需要解压指针反而可能增加开销。
【RocketMQ】RocketMQ应用难点
记录一名在读研究生的学习笔记、感悟、开发产物
09-30 923
本文探讨了RocketMQ中消息重复消费的问题及其解决方案，尤其是在CLUSTERING模式下的扩容影响。文章分析了重复消费的原因，如广播模式、负载均衡模式下的多consumerGroup消费、消费者组内的动态变化及网络延迟等，并提出了利用唯一标识进行去重的方法。此外，还讨论了如何选择合适的存储机制以高效处理大量消息标识，如HashMap、MySQL、Redis以及推荐的布隆过滤器等方案。对于防止消息堆积与确保消息不丢失，也给出了相应的策略和技术措施。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

墨崇M柒

网络乞讨一下，嘿嘿嘿~

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

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

打赏作者

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

抵扣说明：

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

余额充值