Java链表的使用

最新推荐文章于 2025-09-25 21:06:56 发布
转载 最新推荐文章于 2025-09-25 21:06:56 发布 · 563 阅读 · 1 ·
CC 4.0 BY-SA版权
原文链接：https://my.oschina.net/rawlins/blog/3102322
文章标签：

#数据结构与算法 #java #开发工具

本文深入探讨Java链表的使用，包括单链表、双向链表和循环链表的特点及操作方法，如插入、删除、查询和修改节点。通过具体代码示例，详细解释了不同链表类型在各种操作中的效率差异。

Java链表的使用

前言

说明：

  • 语言：Java
  • 环境：IntelliJ IDEA
  • JDK版本：1.8
  • 源码：GitHub
  • 链表的插入、查询、排序通常涉及算法，本文重点是探究链表，并非算法，因此代码只是以最通俗易懂的方式编写

在学习Java链表的使用之前，需要先了解Java引用类型的使用

int a = 10;
int b = a;
b++;
System.out.println(a);

上面这段代码的运行结果为：10。在int b = a;这个操作中，实际是将a的值赋给b，所以b++;不会影响a的值，这是基本数据类型的特性。

//Employee是描述员工信息的实体类
Employee employee1 = new Employee(1,"xiaoming",30);
Employee employee2 = employee1;
employee2.seteName("liumei");
System.out.println(employee1.toString());

上面这段代码的运行结果为：Employee{eId=1, eName='liumei', eAge=30}。这就说明，在Employee employee2 = employee1;操作中，使得employee1和employee2共享相同的数据，因此两个变量任意一个改变数据，都会影响对方。

实际上，new是在内存中划分一个空间来存储数据，而接收new的employee1变量只是一个指针，指向这个内存空间，当把这个变量赋给变量employee2时，employee2也将是指向和employee1相同内存空间的指针，因此操作这两个变量，实际上都是对同一内存空间的操作。

单链表

单链表

特点：

  • 拥有next指针，指向下一个节点
  • 只能单向的从头结点为起点操作链表
  • 在链表首部插入节点效率高，在链表尾部插入节点效率低

插入节点：

     /**
     * 在链表尾部插入数据
     */
    public boolean addLast(Employee employee){
        Node node = new Node(employee); //创建要插入的节点
        Node temp = this.head;  //创建辅助指针指向head节点
        while (true){   //移动辅助指针到当前链表最后一个节点
            if(temp.next==null){break;}
            temp = temp.next;
        }
        temp.next = node;   //将要插入的节点插入到链表尾部
        this.length++;
        return true;
    }

    /**
     * 在链表首部插入数据
     */
    public boolean addFirst(Employee employee){
        Node node = new Node(employee); //创建要插入的节点
        Node temp = this.head;  //创建辅助指针指向head节点
        if(isEmpty()){    //链表为空情况
            this.head.next = node;  //直接在head后插入节点
        }else{  //链表不为空情况
            temp = temp.next;   //移动temp到第一个有效节点
            this.head.next = node;  //将要插入节点插入到head节点后
            node.next = temp;   //将其他节点连接到刚插入的节点上
        }
        this.length++;
        return true;
    }

    /**
     * 在index节点之后插入节点，索引从0开始
     */
    public boolean addIndex(Employee employee,int index){
        if(isEmpty()||index>=this.length||index<0){ return false;}//空链表、索引格式范围不正确则插入失败
        Node node = new Node(employee); //创建要插入的节点
        Node temp = this.head;  //创建辅助指针指向head节点
        for (int i = 0;i<=index;i++){   //将辅助指针移动到目标节点
            temp = temp.next;
        }
        node.next = temp.next;  //让新节点的next指向目标节点之后的节点
        temp.next = node;   //让辅助指针指向新节点
        this.length++;
        return true;
    }

删除节点：

     /**
     * 删除最后一个节点
     */
    public boolean deleteLast(){
        if(isEmpty()){return false;}
        Node temp = this.head;  //创建辅助指针指向head节点
        while (true){   //移动辅助指针到当前链表最后一个节点的前一个节点
            if(temp.next.next==null){break;}
            temp = temp.next;
        }
        temp.next = null;   //断开与最后一个节点的的连接
        this.length--;
        return true;
    }

    /**
     * 删除第一个节点
     */
    public boolean deleteFirst(){
        if(isEmpty()){return false;}
        Node temp = this.head.next;  //创建辅助指针指向第一个有效节点
        this.head.next = temp.next; //将头节点连接到第一个有效节点之后的节点
        this.length--;
        return true;
    }

    /**
     * 删除指定索引节点，索引从0开始
     */
    public boolean deleteIndex(int index){
        if(isEmpty()||index>=this.length||index<0){ return false;}//空链表、索引格式范围不正确则删除失败
        Node temp = this.head;  //创建辅助指针指向头结点
        for (int i = 0;i<index;i++){    //将辅助指针移动到目标节点之前的节点
            temp = temp.next;
        }
        temp.next = temp.next.next; //让辅助指针指向目标节点之后的节点
        this.length--;
        return true;
    }

查询节点：

    /**
     * 查看index位置的数据，索引从0开始
     */
    public Employee getEmployee(int index){
        if(isEmpty()||index>=this.length||index<0){ return null;}//空链表、索引格式范围不正确则查询失败
        Node temp = this.head;  //创建辅助指针指向头结点
        for (int i = 0;i<=index;i++){    //将辅助指针移动到目标节点
            temp = temp.next;
        }
        return temp.data;   //返回数据
    }

修改节点：与查询类似，需要定制规则

双向链表

双向链表

特点：

  • 拥有next指针和previous指针，next指针指向下一个节点，previous指针指向前一个节点
  • 允许双向操作链表
  • 双向链表通常拥有头结点和尾结点，这样从双端插入数据效率都很高
  • 由于允许双向操作链表，所以查询效率高于单链表

插入节点：

    /**
     * 在链表尾部插入数据
     */
    public boolean addLast(Employee employee){
        Node node = new Node(employee); //创建要插入的节点
        if(isEmpty()){  //如果链表为空
            this.head.next = node;  //将head和last节点连接到node
            this.last.pre = node;
            node.next = this.last;  //将node的next和pre连接到last和head
            node.pre = this.head;
        }else{  //如果链表不为空（注意顺序）
            node.next = this.last;  //将node连接到last和当前最后一个节点
            node.pre = this.last.pre;
            this.last.pre.next = node;  //将last和当前最后一个节点连接到node
            this.last.pre = node;
        }
        this.length++;
        return true;
    }

    /**
     * 在链表首部插入数据
     */
    public boolean addFirst(Employee employee){
        Node node = new Node(employee); //创建要插入的节点
        if(isEmpty()){  //如果链表为空
            this.head.next = node;  //将head和last节点连接到node
            this.last.pre = node;
            node.next = this.last;  //将node的next和pre连接到last和head
            node.pre = this.head;
        }else{  //如果链表不为空（注意顺序）
            node.next = this.head.next;  //将node连接到head和当前第一个节点
            node.pre = this.head;
            this.head.next.pre = node;  //将head和当前第一个节点连接到node
            this.head.next = node;
        }
        this.length++;
        return true;
    }

    /**
     * 在index节点之后插入节点，索引从0开始
     */
    public boolean addIndex(Employee employee,int index){
        if(isEmpty()||index>=this.length||index<0){return false;}//空链表、索引格式范围不正确则插入失败
        Node node = new Node(employee);;
        Node temp;
        if((index+1)<=this.length/2){   //如果要插入的位置小于链表总长度一半，则在前半段插入
            temp = this.head;
            for (int i = 0;i<=index;i++){
                temp = temp.next;
            }
            node.next = temp.next;
            node.pre = temp;
            temp.next.pre = node;
            temp.next = node;
        }else{  //如果要插入的位置大于链表总长度的一半，则在后半段插入
            temp = this.last;
            for (int i = 0;i<=this.length-(index+1);i++){
                temp = temp.pre;
            }
            node.next = temp.next;
            node.pre = temp;
            temp.next.pre = node;
            temp.next = node;
        }
        this.length++;
        return true;
    }

删除节点：

    /**
     * 删除最后一个节点
     */
    public boolean deleteLast(){
        if(isEmpty()){return false;}
        this.last.pre.pre.next = this.last; //将最后一个节点的前一个节点的next指向last
        this.last.pre = this.last.pre.pre;//将last的pre指向最后一个节点的前一个节点
        this.length--;
        return true;
    }

    /**
     * 删除第一个节点
     */
    public boolean deleteFirst(){
        if(isEmpty()){return false;}
        this.head.next.next.pre = this.head;//将第一个节点的后一个节点的pre指向head
        this.head.next = this.head.next.next;//将head的next指向第一个节点的后一个节点
        this.length--;
        return true;
    }

    /**
     * 删除指定索引节点，索引从0开始
     */
    public boolean deleteIndex(int index){
        if(isEmpty()||index>=this.length||index<0){return false;}//空链表、索引格式范围不正确则删除失败
        Node temp;
        if((index+1)<=this.length/2){   //如果要插入的位置小于链表总长度一半，则在前半段删除
            temp = this.head;
            for (int i = 0;i<=index;i++){
                temp = temp.next;
            }
            temp.pre.next = temp.next;
            temp.next.pre = temp.pre;
        }else{  //如果要插入的位置大于链表总长度的一半，则在后半段删除
            temp = this.last;
            for (int i = 0;i<=this.length-(index+1);i++){
                temp = temp.pre;
            }
            temp.pre.next = temp.next;
            temp.next.pre = temp.pre;
        }
        this.length--;
        return true;
    }

查找节点：

    /**
     * 查看index位置的数据，索引从0开始
     */
    public Employee getEmployee(int index){
        if(isEmpty()||index>=this.length||index<0){return null;}//空链表、索引格式范围不正确则删除失败
        Node temp;
        if((index+1)<=this.length/2){   //如果要插入的位置小于链表总长度一半，则在前半段查找
            temp = this.head;
            for (int i = 0;i<=index;i++){
                temp = temp.next;
            }
            return temp.data;
        }else{  //如果要插入的位置大于链表总长度的一半，则在后半段查找
            temp = this.last;
            for (int i = 0;i<=this.length-(index+1);i++){
                temp = temp.pre;
            }
            return temp.data;
        }
    }

修改节点：与查询类似，需要定制规则

循环链表

循环链表

特点：

  • 拥有next指针，指向下一个节点
  • 链表的最后一个节点的next指向第一个节点，形成循环
  • 为了实现环的完整性，循环链表通常不需要头节点
  • 只能进行一个方向的循环

循环链表的增删改查需要根据需求确定，普通实现可类比将最后一个节点的next连接到首节点的单链表。实际上需要根据需求定制在环的什么位置插入，在什么位置删除，以及判定循环一圈和循环终止的条件

双向循环链表

双向循环链表

特点：

  • 拥有next指针和previous指针，next指针指向下一个节点，previous指针指向前一个节点
  • 链表的最后一个节点的next指向第一个节点，第一个节点的previous指正指向最后一个节点，形成循环
  • 为了实现环的完整性，循环链表通常不需要头节点
  • 可以进行双向的循环

双向循环链表的增删改查需要根据需求确定，普通实现可类比将最后一个节点的next连接到首节点，首节点的previous连接在最后一个节点的双向链表。实际上需要根据需求定制在环的什么位置插入，在什么位置删除，以及判定循环一圈和循环终止的条件

转载于:https://my.oschina.net/rawlins/blog/3102322

chenxina7314
关注
Java数据结构---链表的基本用法（如创建等基本使用方法）
gaoqiandr的博客
01-05 1757
本文简单地介绍了如何使用Java实现数据结构中的链表
Java集合-List接口-LinkedList
baidu_38126306的博客
09-20 1233
Java集合——LinkedList 1. Java LinkedList 特性 LinkedList（链表）底层是用双向链表实现的存储。是一种常见的基础数据结构，是一种线性表，但是并不会按线性的顺序存储数据，而是在每一个节点里存到下一个节点的地址。 链表可分为单向链表和双向链表： [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2ZNePWKr-1600610375482)(D:\JavaAno\pictures\单向链表&双向链表示例.png)] 与 A
java 中链表的定义与使用方法
08-31
主要介绍了java 中链表的定义与使用方法的相关资料,需要的朋友可以参考下
Java之链表
kevien_G1的博客
09-25 1101
因为链表是由多个节点所构成的，又因为内部类是能对外隐藏，所以我们通过内部类的方式来进行构建节点。在这里面我们需要定义一个节点的引用和val变量来存放值。
单链表顺序插入节点
莫逸雪的博客
12-23 644
主函数测试： public static void main(String[] args){ Scanner scanner=new Scanner(System.in); //先创建节点 HeroNode hero1=new HeroNode(1,"宋江","及时雨"); HeroNode hero2=new HeroNode(2...
链表及其基本操作（Java语言版）
helloWorld的博客
07-26 3262
链表的基本操作
LinkedList:使用 Java 实现链表
06-13
链表是一种基础且重要的数据结构，它在计算机科学中扮演着关键角色，特别是在处理动态数据集合时。在Java中，`LinkedList`类是`java.util...通过分析和运行这些代码，你可以加深对Java链表实现的理解，并提升编程技能。
java使用链表实现约瑟夫环
08-26
Java 使用链表实现约瑟夫环 约瑟夫环是一个经典的数学应用问题，它描述了n个人围坐在一张圆桌周围，从编号为k的人开始报数，数到m的那个人出列；他的下一个人又从1开始报数，数到m的那个人又出列；依此规律重复下去...
Java链表总结
m0_56987404的博客
05-04 1489
链表简单的curd操作入门
Java链表
weixin_53244209的博客
12-20 3169
链表一、链表1、什么是链表2、链表共分几类？1、单链表2、双向链表3、循环链表 一、链表 1、什么是链表 链表 [Linked List]：链表是由一组不必相连（不必相连：可以连续也可以不连续）的内 存结构（节点），按特定的顺序链接在一起的抽象数据类型。 补充： 抽象数据类型（Abstract Data Type [ADT]）：表示数学中抽象出来的一些操作的集合。 内存结构：内存中的结构，如：struct、特殊内存块…等等之类； 数组和链表的区别和优缺点： 数组是一种连续存储线性结构，元素类型相同
java 链表的使用
Stu_art的博客
09-16 1230
链表与数组的区别 数组的存放为连续的内存空间， 链表不需要，任意碎片式的内存空间都可以形成链表。 链表的分类 1 双端链表 既有next指向下一个数据也有previous指向前一个数据，可以双向遍历。 2 单端链表 只有next指向下一个数据，只能单向遍历。 链表的基本操作 1 访问----O(N) 需要遍历，从头找到尾 2 搜索----O(N) 需要遍历，从头找到尾 3 插入----O(1) 直接需要插入的位置断开指针，使上一个的指针指向新的元素的位置，新元素的下一个指向原本的下一个元素 4 删除----
JAVA链表的使用
m0_61882402的博客
05-25 311
废话不多说，直接看代码，注释应该说的很明白了 public class MyLinkedList { //头节点指针 private Node head; //尾节点指针 private Node last; //链表实际长度 private int size; /** * 链表插入元素 * @param index 插入位置 * @param data 插入元素 */ public void i
Java中链表（Linked list）用法（单链表，双链表）
Sueko的博客
03-07 7311
Java中链表的用法1.链表的概念2.链表的操作3.Java中链表的使用
java链表操作
guoliang1992
12-27 557
本来该学习java链表源码了，在学习源码之前先复习一下java的链表知识 下面是java操作链表的几个简单例子： 先定义一个Node的类public class Node { private int record;//变量 private Node nextNode;// public Node(){ } public Node(int record){
Java 链表
weixin_34342207的博客
06-01 155
按链表的组织形式分有ArrayList和LinkList两种。ArrayList内部其实是用数组的形式实现链表，比较适合链表大小确定或较少对链表进行增删操作的情况，同时对每个链表节点的访问时间都是constant；而LinkList内部以一个List实现链表，比较适合需要频繁对链表进行操作的情况，对链表节点的访问时间与链表长度有关O(N)。 另外，根据实现形式可以分为直接式（想不出什...
Java语言中链表和双向链表的实现
myali88的专栏
12-04 991
出处:csdn链表是一种重要的数据结构，在程序设计中占有很重要的地位。C语言和C＋＋语言中是用指针来实现链表结构的，由于Java语言不提供指针，所以有人认为在Java语言中不能实现链表，其实不然，Java语言比C和C＋＋更容易实现链表结构。Java语言中的对象引用实际上是一个指针（本文中的指针均为概念上的意义，而非语言提供的数据类型），所以我们可以编写这样的类来实现链表中的结点。
java 链表
qq_57163230的博客
06-25 740
Java实现单链表，双向链表，循环链表。
JAVA-链表
Lizhihao_的博客
11-17 2390
LinkedList的底层是双向链表结构，由于链表没有将元素存储在连续的空间中，元素存储在单独的节 点中，然后通过引用将节点连接起来了，因此在在任意位置插入或者删除元素时，不需要搬移元素，效率比较高。在集合框架中，LinkedList也实现了List接口，具体如下：【说明】1. LinkedList实现了List接口2. LinkedList的底层使用了双向链表3. LinkedList没有实现RandomAccess接口。
java 链表使用方法，leecode如何考察
最新发布
09-26
### Java 链表使用方法 在 Java 中，链表通常通过自定义节点类来实现。以下是一个简单的单链表节点类定义： ```java class ListNode { int val; ListNode next; ListNode(int x) { val = x; } } ``` #### 创建链表 可以通过创建节点并将它们连接起来来创建链表： ```java ListNode head = new ListNode(1); ListNode second = new ListNode(2); ListNode third = new ListNode(3); head.next = second; second.next = third; ``` #### 遍历链表 使用循环遍历链表中的每个节点： ```java ListNode current = head; while (current != null) { System.out.println(current.val); current = current.next; } ``` #### 插入节点 在链表中插入新节点，例如在链表头部插入节点： ```java ListNode newNode = new ListNode(0); newNode.next = head; head = newNode; ``` #### 删除节点 删除链表中的节点，例如删除指定值的节点： ```java ListNode prev = null; ListNode current = head; int target = 2; while (current != null) { if (current.val == target) { if (prev == null) { head = current.next; } else { prev.next = current.next; } break; } prev = current; current = current.next; } ``` ### LeetCode 对 Java 链表的考察方式 #### 链表的基本操作 LeetCode 会考察链表的插入、删除、反转等基本操作。例如，LeetCode 206 题反转链表，需要将链表中的节点顺序反转。 ```java class Solution { public ListNode reverseList(ListNode head) { ListNode pre = null; ListNode cur = head; while (cur != null) { ListNode nxt = cur.next; cur.next = pre; pre = cur; cur = nxt; } return pre; } } ``` #### 链表的合并与分割 如 LeetCode 21 题合并两个有序链表，需要将两个有序链表合并成一个新的有序链表；LeetCode 86 题分隔链表，需要将链表按给定值进行分割。 ```java class Solution { public ListNode mergeTwoLists(ListNode l1, ListNode l2) { ListNode dummy = new ListNode(0); ListNode current = dummy; while (l1 != null && l2 != null) { if (l1.val < l2.val) { current.next = l1; l1 = l1.next; } else { current.next = l2; l2 = l2.next; } current = current.next; } if (l1 != null) { current.next = l1; } if (l2 != null) { current.next = l2; } return dummy.next; } } ``` #### 链表的查找与判断 LeetCode 会考察链表中特定节点的查找，如链表的中间节点（LeetCode 876 题）；还会考察链表的一些特性判断，如判断链表是否为回文链表（LeetCode 234 题）[^3]。 ```java class Solution { public ListNode middleNode(ListNode head) { ListNode slow = head; ListNode fast = head; while (fast != null && fast.next != null) { slow = slow.next; fast = fast.next.next; } return slow; } } ``` #### 链表的相交与环 考察链表是否相交（LeetCode 160 题）以及链表是否存在环（LeetCode 141 题）。对于链表相交问题，可以使用哈希表来解决[^2]。 ```java import java.util.HashSet; import java.util.Set; class Solution { public ListNode getIntersectionNode(ListNode headA, ListNode headB) { Set<ListNode> set = new HashSet<>(); ListNode nodeA = headA; while (nodeA != null) { set.add(nodeA); nodeA = nodeA.next; } ListNode nodeB = headB; while (nodeB != null) { if (set.contains(nodeB)) { return nodeB; } nodeB = nodeB.next; } return null; } } ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值