算法学习———链表（Java版）

最新推荐文章于 2023-03-26 14:45:57 发布
最新推荐文章于 2023-03-26 14:45:57 发布
阅读量419 收藏
点赞数 4
文章标签： 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Sencq/article/details/127140562
版权

 leetcode本周刷题路线：

 203. 移除链表元素（简单）：

        题目描述：

        给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.value  ==  val的节点，并返回新的头节点。

        示例：

 

        解题思路：

        设置两个指针 pre 和 cur ，其中 cur 指针用于检测当前节点的值是否与 val相等，若相等则通过 pre 指针将 cur 所在的节点删除 。在链表的 head 前添加一个值为 -1的节点并将原来的 head 指向新添加的节点处， pre 指向 head 处，cur 指向 pre.next 处。pre 与 cur 同时开始遍历链表直至 cur == NULL ，遍历完成则程序运行结束。

        删除节点的步骤：

                pre.next = cur.next;

                cur = cur.next;

        解题代码：

/**
 * 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 cur, pre;
        head = new ListNode(-1, head);
        pre = head;
        cur = pre.next;
        while(cur != null){
            if(cur.val == val){
                pre.next = cur.next;
                cur = cur.next;
                continue;
            }
            pre = pre.next;
            cur = pre.next;
        }
        return head.next;
    }
}

206. 反转链表（简单）：

        题目描述：

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

        示例：

        解题思路：头插法反转链表

        新建一个链表头节点 newhead 、指针 p 和 temp ，其中 p 指针指向 head，temp 指针用于保存 p 所在节点的下一节点的地址。p 指针从 head 处遍历链表，指针 p 指向某一结点，就将该节点添加至newhead后方。当 p == null 时，程序运行结束。

        头插法的步骤：

                p.next = newhead.next;

                newhead.next = p;

        解题代码：

/**
 * 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(), p, temp;
        p = head;
        while(p != null){
            temp = p.next;
            p.next = newhead.next;
            newhead.next = p;
            p = temp;
        }
        return newhead.next;
    }
}

 24.两两交换链表中的节点（中等）：

        题目描述：

        给你一个链表，两两交换其中相邻的节点，并返回交换后链表的头节点。你必须在不修改节点内的值的情况下完成本题（即只能进行节点交换）。

        示例：

        

        解题思路： 

        设置三个指针 pre、p、q ，pre 指向一个为设置值的节点且 pre.next = head，指针 p、q、head 同时指向指针 pre 所指处。将指针 p、q 两两指向链表中相邻节点( p 在 q前)，交换指针p、q 所在位置节点的位置后，通过指针 pre 将交换节点后的部分连接起来。

        指针 p、 q 所指节点交换并与链表链接步骤：

                p.next = q.next;

                q.next = p;

                pre.next = q;

        解题代码：

/**
 * 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) {
        ListNode pre = new ListNode(), p, q;
        System.out.print(pre.val);
        pre.next = head;
        p = q = head = pre;
        while(p.next != null){
            p = pre.next;
            q = p.next;
            if(q == null)
                break;
            p.next = q.next;
            q.next = p;
            pre.next = q;
            pre = p;
        }
        return head.next;
    }
}

19. 删除链表的倒数第N个结点（中等）：

        题目描述：

        给你一个链表，删除链表的倒数第n个结点，并且返回链表的头节点。

        示例：

        

        解题思路：双指针法

        在链表表头前添加一个值域为 -1 的节点，将原来指向链表头部的指针 head 指向新添加的节点，设置指针 p1、p2并指向指针 head 所指节点处。先让指针 p1 移动 n 步后，再让指针 p1、p2同时向后移动，此时指针 p1 与 指针 p2 的距离固定为 n，每次移动距离均为1，当指针 p1 移动到链表最后一个节点时，p2当前位置即为所要删除位置节点的前一个节点（也即链表倒数第 n 个节点），执行 p2.next = p2.next.next；语句即可从链表删除该节点。

        解题代码：

/**
 * 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 p1, p2;
        head = new ListNode(-1, head);
        p1 = p2 = head;
        while(n-- != 0)
            p1 = p1.next;
        while(p1.next != null){
            p1 = p1.next;
            p2 = p2.next;
        }
        p2.next = p2.next.next;
        return head.next;
    }
}

160. 相交链表（简单）：

        题目描述：

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

        示例：

        解题思路：

        设置两个指针 p1, p2，分别指向 headA，headB，当指针 p1、p2 遍历完当前链表后，交换两个指针所指的链表，并从其头节点重新遍历，消除指针 p1、p2 移动的距离差使指针 p1、p2 在第二次经过两链表交点时走过的距离相等。

        解题代码：

/**
 * 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 p1, p2;
        p1 = headA; 
        p2 = headB;
        while(p1 != p2){
            p1 = p1 == null ? headB : p1.next;
            p2 = p2 == null ? headA : p2.next;
        }
        return p1;
    }
}

142.环形链表 II（中等）：

        题目描述：

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

        示例：

        

 

        解题思路：快慢指针

        设置两个指针，分别为 fast 和 slow，指针 fast 一次移动两步，指针 slow 一次移动一步，若该指针 fast 最终会指向 null ，则该链表无环；若该链表有环则指针 fast 和指针 slow 必定会在环内相遇且指针 fast 已在环内循环了至少一次，此时指针 fast 移动的距离是指针 slow 移动距离的两倍。

        设链表表头到入环点的距离为 a，入环点到快慢指针相遇点的距离为 b，快慢指针相遇点到下一次入环点的距离为 c。可得：指针 fast 移动的距离为 a + b + c + b， 指针 slow 移动的距离为 a + b。又因为指针 fast 移动的距离是指针 slow 的两倍，故可列出等式 a + b + c + b = 2（a + b），易得 a = c，即，此时再设置一个指针 temp 从链表表头和指针 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 null; 
        ListNode slow = head, fast = head;
        boolean hasCycle = false;
        while (fast.next != null && fast.next.next != null) {
            slow = slow.next;
            fast = fast.next.next;
            if (slow == fast) {
                hasCycle = true;
                break;
            }
        }
        if (hasCycle) {
            ListNode temp = head;
            while (slow != temp) {
                slow = slow.next;
                temp = temp.next;
            }
            return temp;
        } 
        else 
            return null;
    }
}

学习小结：

        链表是比较常见的数据结构之一，也是一些更高级的数据结构的基础。熟练掌握链表对于往后算法和数据结构的学习至关重要，同时，与链表相关的操作必定离不开指针，因此熟悉指针的原理和作用也同样重要。在本周对于链表的学习中学习到了许多只针对操作方法，例如 ” 双指针 “、” 快慢指针 “等，其中 ” 快慢指针 ‘ 这一操作十分的巧妙，让我印象深刻，让我对链表和指针都有了更深层次的理。“ 环形链表 II ” 这道题是我做的第一道通过数学思想来理解的算法题，其中就用到了 ” 快慢指针 “ ，为了理解这道题还是花了点时间的，虽然很难很费脑子，但理解这道题的一瞬间的成就感和满足感是无与伦比的，这就是算法的乐趣吧！

Sensen.
关注
  • 4
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
金典链表算法题（Java实现，简单详细）+题目链接
m0_62468521的博客
12-11 736
金典链表算法题 Java实现，简单详细，轻松拿捏链表！
链表经典练习题合集（Java版）
qq_58284486的博客
03-15 2493
最近开始了数据结构的学习，数据结构是比较抽象的，需要不断的进行画图总结，不断地刷相关的题来加强自己对于数据结构的理解，我会不断地更新博客以及上传自己的做题记录以及题解，希望可以给大家带来帮助，也希望大家可以指出我存在的问题，共同进步☺ 这是我的gitee链接，所有的代码都已上传至gitee中：gitee代码仓库 目录 移除链表元素 反转链表 链表的中间结点 链表中倒数第k个结点 合并两个有序链表 移除链表元素 原题链接：203.移除链表元素 题目描述： 给你...
Java 链表大厂算法题目总结，原理都给你讲明白了
u013749113的博客
02-22 300
​ 链表(Linked List)是一种常见的线性结构。它不需要一块连续的内存空间，通过指针即可将一组零散的内存块串联起来。我们把内存块成为链表的节点，为了将所有的节点串起来，每个链表的节点除了存储数据之外，还需要记录链表的下一个节点的地址，这个记录下个节点地址的指针我们叫做后驱指针。搜索链表需要O(N)的时间复杂度，这点和数组类似，但是链表不能像数组一样，通过索引的方式以O(1)的时间读取第n个数。链表的优势在于能够以较高的效率在任意位置插入或者删除一个节点。
Java算法—链表
a402498234的博客
09-01 970
求链表长度、反转链表、回文链表、环形链表
Java数据结构和算法——链表
最新发布
人在杰途的博客
03-26 681
在表头增加节点：删除节点：①、单向链表的具体实现//链表节点的个数//头节点size = 0;//链表的每个节点类//每个节点的数据//每个节点指向下一个节点的连接//在链表头添加元素}else{size++;return obj;//在链表头删除元素size--;return obj;//查找指定元素，找到了返回节点Node，找不到返回null}else{tempSize--;//删除指定的元素，删除成功返回true。
数据结构与算法 —— Java 实现（链表）
01-21
数据结构与算法 —— Java 实现（链表）一、单链表1.1 链表的定义1.2 链表添加一个新的节点1.3 判断当前节点是否为最后一个节点 （isLast）1.4 删除下一节点 （removeNext）1.5 显示节点信息（show）1.6 插入一个...
针对在校大学生的C语言入门学习——链表源码
01-26
【标题】"针对在校大学生的C语言入门学习——链表源码"，旨在为初学者提供C语言中链表数据结构的基本概念和实现方法。链表是计算机科学中一种重要的抽象数据类型，它与数组不同，不连续存储元素，而是通过指针链接...
线性表——链表PPT学习教案.pptx
10-01
线性表是一种基础的数据结构，通常用于组织和处理一系列有序数据。在计算机科学中，线性表有两种主要的存储方式：...理解链表的工作原理和操作方法对于深入学习数据结构和算法至关重要，尤其是在内存管理有限的环境中。
Java算法实例-双向链表操作
08-22
本实例聚焦于Java中的一个重要数据结构——双向链表，它在很多场景下都有着广泛的应用。双向链表与单链表相比，其独特之处在于每个节点不仅包含指向下一个节点的指针，还包含指向前一个节点的指针，这使得在链表中的...
链表经典练习题合集2（Java版）
qq_58284486的博客
03-18 1303
本篇主要为leetcode上链表部分中等及困难难度练习题，链表部分的习题画图十分重要，只要链表结构画出来，再写代码解决问题就容易很多。做完这些难度高的习题后发现，其实中等难度的习题只是将两个甚至三个以上的知识点融汇到一个题目中，当掌握链表的基本处理方法后，并用心去钻研，解决这些习题其实也不是想象中的那么难. 本篇中的例题代码均已更新在gitee代码仓库中，仓库链接：gitee代码仓库 希望我的解决思路可以给大家带来帮助，也希望大家可以指出我思路或者逻辑上的不足☺☺ 目录 两数相加 删除链表.
Java数据结构与算法——链表面试题
baijaiyu的博客
09-13 1326
本文为链表相关面试题，每道题均附讲解及对应连接。 一：反转一个单链表。 链接：206. 反转链表 - 力扣（LeetCode）https://leetcode.cn/problems/reverse-linked-list/description/ 1.题目：给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。2. 2.解题 我的思路是：从第二个结点开始，依次将后一个结点的指向改变为指向前一个结点。如果直接改变指向，那么就无法找到下一个结点了，所.....
算法知识梳理(9) - 链表算法第一部分
weixin_34256074的博客
12-21 153
一、概要 本文介绍了有关链表的算法的Java代码实现，所有代码均可通过 在线编译器 直接运行，算法目录： 新建链表 反转链表（递归和非递归实现） 获得链表倒数第k个结点 获得链表的中间结点 删除链表结点 交换链表结点 在本章的讨论当中，所有的链表都包含一个头结点Node，头结点不存储数据，其next指针指向第一个普通链表结点，每个普通链表结点包含一个int类型的数据项。 二、代码实现 2.1...
Java链表习题
qq_46249770的博客
11-15 375
1.在Java语言中要模拟链表中的节点，该如何声明。 public class Node1 { int data; Node1 next; public Node1(int data) { this.data=data; this.next=null; } } 2.如果链表中的节点不只记录单一数据，例如每个节点除了有指向下一个节点的指针外，还包括记录每一位学生的姓名、学号、成绩，请问在Java中要模拟链表中的此类节点，该如何声明。 public class Node { int data; int np;
Java链表的常用算法原理
perturb的博客
03-13 1310
链表算法： 1.给定一个链表，但是不知道链表大小，要求遍历一次，找到链表的中间位置 方法：快慢指针法 定义两个指针都指向head节点，fast指针每次移动两步，slow指针每次移动一步，当fast不能再往后走时，slow此时指向的是中间值 代码： //找到链表的中间值 public Node findMid() { //定义快指针fast Node fast = head; //定义慢指针slow Node slow = head; while ((fas..
java链表算法题一
小文哥的博客
09-10 481
题目描述编写代码，以给定值x为基准将链表分割成两部分，所有小于x的结点排在大于或等于x的结点之前 给定一个链表的头指针 ListNode* pHead，请返回重新排列后的链表的头指针。注意：分割以后保持原来的数据顺序不变。解答如下：import java.util.*;/** * 单向链表节点类 */ class ListNode { int val; //
java链表算法题,4.1算法题-链表反转
weixin_39617405的博客
03-12 182
定义一个函数，输入一个链表的头节点，反转该链表并输出反转后链表的头节点。示例:输入: 1->2->3->4->5->NULL输出: 5->4->3->2->1->NULL限制：0 <= 节点个数 <= 5000## 补充下面的代码```/*** Definition for singly-linked list.* publi...
链表经典算法题（Java）
weixin_43855930的博客
07-22 452
求单链表中有效节点的个数(如果有头结点，不统计头结点) public static int getLenth(Node head){ if (head.next == null) { return 0; } int lenth = 0; //让辅助指针指向头结点的下一个，就没有统计头结点 Node temp = head.next; while(temp != null){
JAVA实现链表面试题
bin的主栏
07-08 5970
这篇文章主要介绍了JAVA相关实现链表的面试题，代码实现非常详细，每一个方法讲解也很到位，特别适合参加Java面试的朋友阅读。 这份笔记整理了整整一个星期，每一行代码都是自己默写完成，并测试运行成功，同时也回顾了一下《剑指offer》这本书中和链表有关的讲解，希望对笔试和面试有所帮助。 本文包含链表的以下内容： 　　1、单链表的创建和遍历 　　2、求单链表中

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值