Java实现数据结构---链表

已于 2024-05-31 14:49:00 修改
阅读量203 收藏
点赞数 1
分类专栏： 数据结构与算法 文章标签： Java 数据结构 链表
于 2019-06-19 10:44:20 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lxx19941220/article/details/90050412
版权

文章目录

链表定义

链表(Linked list)是一种在物理上不连续、非顺序的数据结构，由若干个节点(Node)组成。链表中元素的逻辑顺序是通过链表中的指针链接次序实现的。
主要具有以下特点:

  • 相邻两个数据元素之间有指针连接。
  • 最后一个元素的后续指针为NULL(双端链表,循环链表除外)。
  • 链表与数组比较相比较,链表的空间能够按需分配,没有内存空间的浪费(但是元素间相连接的指针需要一些额外的开销)。
  • 链表中会有至少两个部分:数据项,以及引用指针。
  • 链表可以在常数时间内扩展（时间复杂度O(1)）。
  • 链表在访问某个元素时开销比较大(时间复杂度O(N))。

存储原理

链表在内存中的存储方式是随机存储(链式存储)的, 链表的每一个节点分布在内存的不同位置, 依靠next指针关联起来。
在这里插入图片描述

单向链表

单向链表包含多个结点，每个结点有一个指向后续元素的next指针，表中的最后一个结点的next指针值为NULL，标识链表的结束。具体模型如下：
在这里插入图片描述
单项链表的结点类：

package com.xxliao.datastructure.linerar_list.linked_list.single;

/**
 * @author xxliao
 * @description: 单向链表节点类
 * @date 2024/5/28 12:31
 */
public class Node {
    
    //存储数据
    private Object data;

    //下个节点
    public Node next;

    //构造
    public Node(Object data) {
        this.data = data;
    }

    //toString查看输出
    public String toString() {
        return "Node [data=" + data + ", next=" + next + "]";
    }
}

单向链表实现：

package com.xxliao.datastructure.linerar_list.linked_list.single;

/**
 * @author xxliao
 * @description: 单向链表
 * @date 2024/5/28 12:32
 */

public class SingleLinkedList {

    //表头结点
    private Node head;

    //链表长度
    private int size;

    //构造,使表头节点为null
    public SingleLinkedList() {
        head = null;
        size = 0;
    }

    //是否为空,判断表头是否为空
    public boolean isEmpty() {
        return head == null;
    }

    //在开始位置添加
    public void addFirst(Object data) {
        //创建新节点
        Node addNode = new Node(data);
        //使新节点的next指向链表的表头
        addNode.next = head;
        //表头指向新节点
        head = addNode;
        //长度加1
        size++;
    }

    //从表头开始删除
    public Object deleteFirst() {
        Node temp = head;
        head = head.next;
        size--;
        return temp.data;
    }

    //在末尾位置添加
    public void addLast(Object data) {
        //创建新节点
        Node addNode = new Node(data);
        //当前节点
        Node current = head;
        //循环找出最末节点
        while(current.next != null) {
            current = current.next;
        }
        //最末节点指向新节点
        current.next = addNode;
        size++;
    }

    //查看链表的所有元素
    public void display() {
        //当前节点
        Node current = head;
        //循环找出最末节点
        while(current.next != null) {
            System.out.println(current.toString());
            current = current.next;
        }
    }

    //判断某元素是否在链表中
    public boolean contain(Object data) {
        //当前节点
        Node current = head;
        if(data == null) {
            //循环找出最末节点
            while(current.next != null) {
                if(current.data == null) {
                    return true;
                }
                current = current.next;
            }
        }else {
            //循环找出最末节点
            while(current.next != null) {
                if(data.equals(current.data)) {
                    return true;
                }
                current = current.next;
            }
        }
        return false;
    }

    //删除链表中的某元素
    public Object delete(Object data) {
        //当前节点
        Node current = head;
        //前一个节点
        Node pred = head;
        if(data == null) {
            //循环找出最末节点
            while(current.data != null) {
                if(current.next == null) {
                    return null;
                }
                pred = current;
                current = current.next;
            }
        }else {
            //循环找出最末节点
            while(!data.equals(current.data)) {
                if(current.next == null) {
                    return null;
                }
                pred = current;
                current = current.next;
            }
        }

        if(current == head) {
            deleteFirst();
        }else {
            pred.next = current.next;
        }
        size--;
        return current.data;
    }
}

双端链表

双端链表在单向链表的实现上多了一个成员变量（last）记录表尾节点，因此双端链表的特点是可以快速的找到表头表尾，在尾部插入以及删除元素时效率将会有很大的提高。双端链表模型如下：
在这里插入图片描述
双端链表节点类：

	 package com.xxliao.datastructure.linerar_list.linked_list.doubly_end;

/**
 * @author xxliao
 * @description: 双端链表节点类
 * @date 2024/5/28 12:46
 */
public class Node {

    //存储数据
    public Object data;

    //下个节点
    public Node next;

    //构造
    public Node(Object data) {
        this.data = data;
    }

    //toString查看输出
    public String toString() {
        return "Node [data=" + data + ", next=" + next + "]";
    }
}

双端链表实现：

	package com.xxliao.datastructure.linerar_list.linked_list.doubly_end;

/**
 * @author xxliao
 * @description: 双端链表实现类
 * @date 2024/5/28 12:47
 */

public class DoublyEndLinkedList {

    //表头节点
    private Node head;
    //表尾节点
    private Node tail;
    //链表长度
    private int size;

    //构造,使表头节点为null
    public DoublyEndLinkedList() {
        head = null;
        tail = null;
        size = 0;
    }

    //是否为空,判断表头是否为空
    public boolean isEmpty() {
        return head == null;
    }

    //在开始位置添加
    public void addFirst(Object data) {
        //创建新节点
        Node addNode = new Node(data);
        //使新节点的next指向链表的表头
        addNode.next = head;
        //表头指向新节点
        head = addNode;
        //长度加1
        size++;
    }

    //从表头开始删除
    public Object deleteFirst() {
        if(isEmpty()) {
            return null;
        }
        Node temp = head;
        head = head.next;
        size--;
        return temp.data;
    }

    //在末尾位置添加
    public void addLast(Object data) {
        Node addNode = new Node(data);
        if(isEmpty()) {
            //空链表，first，last均为addNode
            head = addNode;
        }else {
            tail.next = addNode;
        }
        //最末节点指向新节点
        tail = addNode;
        size++;
    }

    //查看链表的所有元素
    public void display() {
        //当前节点
        Node current = head;
        //循环找出最末节点
        while(current.next != null) {
            System.out.println(current.toString());
            current = current.next;
        }
    }

    //判断某元素是否在链表中
    public boolean contain(Object data) {
        //当前节点
        Node current = head;
        if(data == null) {
            //循环找出最末节点
            while(current.next != null) {
                if(current.data == null) {
                    return true;
                }
                current = current.next;
            }
        }else {
            //循环找出最末节点
            while(current.next != null) {
                if(data.equals(current.data)) {
                    return true;
                }
                current = current.next;
            }
        }
        return false;
    }
}

双向链表

双向链表的每个节点均有一个前驱节点记录指向上一节点，有一个后驱节点指向下一节点，表尾节点后驱节点为NULL。因为双向链表节点间相互指引，那么在查找过程中可以双向遍历。
在这里插入图片描述
Java代码，链表节点声明如下：

package com.xxliao.datastructure.linerar_list.linked_list.doubly;

/**
 * @author xxliao
 * @description: 双向链表的节点类实现
 * @date 2024/5/28 12:54
 */

public class Node {
    //数据
    public Object data;
    //前驱结点
    public Node pre;
    //后驱结点
    public Node next;

    //构造方法
    public Node(Object data) {
        this.data = data;
    }

    //toString
    @Override
    public String toString() {
        return "DLLNode [data=" + data + ", pre=" + pre + ", next=" + next + "]";
    }
}

Java代码，双向链表(这里采用双向双端链表)的实现如下：

	package com.xxliao.datastructure.linerar_list.linked_list.doubly;

/**
 * @author xxliao
 * @description: 双向双端链表的实现类
 * @date 2024/5/28 12:55
 */

public class DoublyLinkedList {
    // 表头节点
    private Node head;
    // 表尾节点
    private Node tail;
    // 链表长度
    private int size;

    // 构造方法,使表头、表尾节点为null
    public DoublyLinkedList() {
        head = null;
        tail = null;
        size = 0;
    }

    // 判断是否为空
    public boolean isEmpty() {
        return head == null;
    }

    // 从表头添加
    public void addFirst(Object data) {
        Node newNode = new Node(data);
        if (isEmpty()) {
            // 空链表，表头表尾都是新结点
            tail = newNode;
        } else {
            // 不是空链表，将新结点添加在first的前驱结点上
            head.pre = newNode;
        }
        // 新结点的后驱结点指向原来的first结点(原来链表表头)，双向指定
        newNode.next = head;
        // 新结点作为表头节点
        head = newNode;
        size++;
    }

    // 从表头删除
    public Object deleteFirst() {
        Node deleteNode = head;
        if (head.next == null) {
            // 只有一个元素，last置为null
            tail = null;
        } else {
            // 将原表头结点的后驱结点（将作为新的表头结点）的前驱结点置为null，
            head.next.pre = null;
        }
        head = head.next;
        size--;
        return deleteNode.data;
    }

    // 从表尾添加
    public void addLast(Object data) {
        Node newNode = new Node(data);
        if (isEmpty()) {
            // 空链表，表头表尾都是新结点
            head = newNode;
        } else {
            // 不是空链表，将新结点添加在last的后驱结点上
            tail.next = newNode;
        }
        // 新结点的前驱结点指向原来的last结点(原来链表表尾)
        newNode.pre = tail;
        // 新结点作为表尾节点
        tail = newNode;
        size++;
    }

    // 从表尾删除
    public Object deleteLast() {
        Node deleteNode = tail;
        if (head.next == null) {
            // 只有一个元素，first置为null
            head = null;
        } else {
            // 将原表尾结点的前驱结点（将作为新的表尾结点）的后驱结点置为null，
            tail.pre.next = null;
        }
        tail = tail.pre;
        size--;
        return deleteNode.data;
    }

    // 添加在某元素后面
    public boolean addAfter(Object d, Object data) {
        // 当前节点
        Node current = head;
        while (!d.equals(current.data)) {
            // 不相等，继续查找
            if (current.next == null) {
                // 没有找到
                return false;
            }
        }
        Node newNode = new Node(data);
        if (current == tail) {
            // 表尾添加
            addLast(data);
        } else {
            // 中间添加
            newNode.next = current.next;
            current.next.pre = newNode;
        }
        current.next = newNode;
        newNode.pre = current;
        size++;
        return true;
    }

    //判断链表是否包含某元素
    public boolean contain(Object data) {
        //当前节点
        Node current = head;
        if(data == null) {
            // 遍历，查找是否有元素相同存在
            while(current.next != null) {
                if(current.data == null) {
                    return true;
                }
            }
        }else {
            // 遍历，查找是否有元素相同存在
            while(current.next != null) {
                if(data.equals(current.data)) {
                    return true;
                }
            }
        }
        return false;
    }
}

完整代码

https://github.com/xxliao100/datastructure_algorithms.git

骑车上酒吧
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
数据结构(Java)---链表
I_am_fine_的博客
08-03 472
数据结构（链表）
Java：数据结构-链表
qq_43336822的博客
10-13 184
1.单链表 （1）带头结点单链表 （2）不带头结点单链表 （3）循环单链表（带头结点） 2.双向链表 （1）带头结点双向链表 （2）不带头结点双向链表 （3）循环双向链表（带头结点）
数据结构之链表（Java实现）
Easenyang的博客
05-18 8267
数据结构中线性表的重要知识之一
数据结构---链表（java实现）
Enl0ve的博客
07-02 8737
近来越来越感觉数据结构和算法的重要性，于是决定花时间整理一下数据结构，一来希望自己能够更加深刻地理解数据结构，二来也希望和大家认真分享一下自己的理解，希望能够一起学习，一起进步，开心每一天。今天先复习一下数据结构中比较常见的链表。本文以图示方法和代码演示详细地对链表及相关演变的链表做一个详细的讲解。希望看到这边文章的各位博友能够评论一下，哪怕是发个“已读”也好，感觉这样才有讨论的学习氛围。单链表这...
数据结构——单链表的Java实现
coder150806的博客
09-05 7797
以前我只是单纯用数组，数组它有固定的长度，是有缺点的，不能随意改变它的长度，而链表可以插入和删除大量元素。 接下来我来介绍下单链表 什么是单链表呢  链表的每个结点中只包含一个指针域，叫做单链表（即构成链表的每个结点只有一个指向直接后继结点的指针，且尾节点的指针为null）。 结点结构如下： 接下来呢，我举一个简单的存储整数的单链表的列子  一.存储整数的单链表分为三部分  1.结点...
java实现单链表
congge
03-06 4万+
链表是java数据结构中一种很基础很常见却也很重要的数据结构，JDK中许多内置jar包基于单链表实现，比如像我们熟悉的linkedList等，为什么要使用链表呢？ 我们知道java中很多集合的底层是基于数组实现的，数组有一个很重要的结构就是索引，通过索引可以快速定位数据，并对数据进行删除等操作，但问题是，我们的业务中，数组有自身的局限性，如果知道索引还好，如果不知道索引就需要一个个遍历查找，然后再...
数据结构——单链表的代码实现（Java）
想着百万年薪努力的小赵
08-22 1220
上接 数据结构——线性表 这篇文章 1、结点类: 单链表是由一个一个结点组成的，因此，要设计单链表类，必须先设计结点类。结点类的成员变量有两个:一个是数据元素，另一个是表示下一个结点的对象引用(即指针)。 步骤如下: (1)头结点的构造（设置指针域即可) (2)非头结点的构造 (3)获得当前结点的指针域 (4)获得当前结点数据域的值 (5)设置当前结点的指针域 (6)设置当前结点数据域的值 注:类似于get和set方法，成员变量是数据域和指针域。 代码实现: (1)List.java:(链表本身也是线性表，
数据结构-链表 JAVA语言实现
08-24
数据结构-链表 JAVA语言实现,包含单向链表、双向链表、循环链表的遍历、删除和插入 详细介绍：http://blog.csdn.net/z740852294/article/details/77369439
Java数据结构篇-链表与数组实现栈.pptx.pptx
12-19
Java数据结构是编程中至关重要的组成部分，它们定义了如何有效地存储和操作数据。在这个话题中，我们将重点关注两种常见的数据结构——链表和数组，并探讨它们如何被用来实现栈这一特定的抽象数据类型。 栈是一种...
链表-使用JAVA语言实现链表数据结构.zip
03-13
链表 链表_使用JAVA语言实现链表数据结构
数据结构-链表(LingkedList)介绍和Java示例代码
07-01
链表是一种重要的线性数据结构，它与数组相比具有独特的特性和优势。链表由一系列节点构成，每个节点包含两部分：数据元素和指向下一个节点的引用。这种结构允许链表在内存中不连续分布，提供了动态扩展和收缩的能力...
图解数据结构--使用Java
04-28
全书内容浅显易懂，利用大量且丰富的图示与范例， 详解复杂的抽象理论，从最基本的数据结构概念开始 说明，再以Java工具加以诠释阵列结构、堆栈、链表 、队列、排序、查找等重要的概念，引领读者抓住重 点轻松进入...
底层数据结构链表，以及java代码实现
麦田里的守望者
04-30 401
[原文：底层数据结构链表，以及java代码实现]（https://jums.club/java-link/） 1 原理介绍 链表和数组的区别在于，数组的插入和删除操作需要整个数组一起跟着动，这样的效率很低。举个例子：打麻将时，当有一个麻将子，其大小正好在已经排序好的麻将中间，如果需要插入进原来的麻将序列，那么需要将之前或者之后的麻将全部移动，这样很费时间，所以链表可以弥补这种不足。 1.1 增 链...
Java数据结构与算法之LinkedList单链表
Andy_lau
10-02 3607
目录： 1.链表概述 2.链表分类即结构 3.单链表 3.1 自定义单链表需要实现的功能(方法) 3.2 单链表实现代码 1.链表概述： 链表具有逻辑连续，物理存储不连续且大小不固定的特点，它是基于指针实现的。其中单链表和单向循环链表中的每一个节点包含了一 个数据域和一个指针域，数据域保存节点的数据，指针域保存节点的下一个节点位置，当需要查找当前节点的下一个节点时，即可通过
数据结构之--链表（Java代码）
Hubbert_Xu的博客
11-18 479
以数组作为存储结构，在无序的情况当中，查找关键字效率十分底下。而在有序的情况下，插入关键字也变得效率底下。而且不管在哪种情况下，数组的删除效率也是很低的。当一个数组创建之后，它的长度是固定的。而链表，可以解决上面的一些问题。一.链结点（Link）在链表中，每个数据项都被包含在“链结点”（Link）中。而链表则是将这些结点给“串联”起来。一个链结点 可能是某个类的对象，例如这个类叫做Link，因为一...
Java基础--单链表的实现
热门推荐
鱼非子
03-25 9万+
Java内部也有自己的链表--LinkedList，但是我们今天不是讨论LinkedList，而是自己来实现一个单链表，包括简单的增删查改，以及使用链表来实现栈和队列这两种数据结构，涉及的方面如下： 单链表的结构 单链表的基本操作 使用虚拟头结点的单链表 单链表实现栈 单链表实现队列 单链表的结构 一种链式存取的数据结构，单链表中的数据是以结点的形式存在，每一个结点...
java代码实现链表
uhana的博客
04-04 1675
java代码实现链表
数据结构——Java 实现链表代码
ZhangJiawen的博客
11-23 582
最近在学习 java，就试着用 java 实现了一下链表，第一次用 java 去写数据结构的知识点，很多地方不熟练，欢迎大家一起讨论； /** * 用 java 实现数据结构中的链表 */ public class ListTest1 { //头结点 Node head = null; /** * 定义节点结构 */ class Node{ Node next = null; int data;
算法（十一）贪婪算法
最新发布
coding is an art
05-31 3214
贪婪算法（Greedy）是一种在每一步都采取当前状态下最好的或者最优的选择，从而希望导致结果也是全局最好或者最优的算法。贪婪算法是当下局部的最优判断，不能回退。贪婪算法的高效性，以及所求得的答案比较接近最优结果，因此贪心算法可以作为辅助算法或者解决一些要求结果不那么精确的问题。
java数据结构-循环链表的设计与实现
03-16
循环链表是一种特殊的链表，它的最后一个节点指向第一个节点，形成...总之，循环链表是一种非常有用的数据结构，可以在很多场景中使用。在Java中，我们可以通过定义Node类和头节点、尾节点来实现循环链表的设计与实现。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

骑车上酒吧

帮到了您，有闲钱，再打赏哦~

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

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

打赏作者

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

抵扣说明：

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

余额充值