数据结构_双向链表的java实现

最新推荐文章于 2024-09-10 10:22:48 发布
最新推荐文章于 2024-09-10 10:22:48 发布
阅读量399 收藏
点赞数
分类专栏： 数据结构 文章标签： 数据结构 双向链表 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013634252/article/details/81230099
版权

这篇文章讲述的是数据结构部分的双向链表的java实现，如有错误或者不当之处，还望各位大神批评指正。

双向链表的特点

  • 物理结构不连续逻辑结构连续
  • 删除和添加操作方便
  • 顺序储存随数据量的增大而增大
  • 查询操作不方便
  • 查询前驱后继元素比较方便

双向链表的基本操作

  1. init:初始化顺序表
  2. destroy：销毁数据表
  3. clear：清空数据表中的元素
  4. length：获取数据表长度
  5. get：获取索引位置的元素
  6. locateElem：定位元素
  7. priorElem：获取元素前驱
  8. nextElem：获取元素后继
  9. put：顺序放入元素
  10. insert：插入元素
  11. replace：替换元素
  12. delete：删除元素
  13. isEmpty：判断顺序表是否为空
  14. print：打印顺序表中的元素

双向链表的java实现

package list;

/**
 * ================================数据结构说明：========================================
 * 
 * 名称：双向链表
 * 
 * 特征：
 *      1. 物理结构不连续逻辑结构连续
 *      2. 删除和添加操作方便
 *      3. 顺序储存随数据量的增大而增大
 *      4. 查询操作不方便
 *      5. 查询前驱后继元素比较方便
 * 
 * 主要方法：
 *      1. init:初始化顺序表
 *      2. destroy：销毁数据表
 *      3. clear：清空数据表中的元素
 *      4. length：获取数据表长度
 *      5. get：获取索引位置的元素
 *      6. locateElem：定位元素
 *      7. priorElem：获取元素前驱
 *      8. nextElem：获取元素后继
 *      9. put：顺序放入元素
 *      10. insert：插入元素
 *      11. replace：替换元素
 *      12. delete：删除元素
 *      13. isEmpty：判断顺序表是否为空
 *      14. print：打印顺序表中的元素
 * 
 * ======================================================================================
*/
/**
 * @author 叶清逸
 * @date 2018年7月24日下午6:53:51
 * @version 1.0
 * @project list
 */
public class DouLinkList implements List {
    /*双向链表的长度*/
    private int LENGTH ;
    /*头指针*/
    private Element head ;

    /*元素类*/
    private class Element{
        Object data ;
        Element next ;
        Element prior ;
    }
    /**
     * @see list.List#init()
     * @explain init方法:初始化双向链表
     * @throws 
     * @author 叶清逸
     * @date 2018年7月24日 下午6:59:22
     */
    @Override
    public void init() {
        head = new Element() ;
        head.data = null ;
        head.next = null ;
        head.prior = null ;

        LENGTH = 0 ;
    }
    /**
     * @see list.List#destroy()
     * @explain destroy方法:销毁双向链表
     * @throws 
     * @author 叶清逸
     * @date 2018年7月24日 下午7:00:57
     */
    @Override
    public void destroy() {
        /*若未初始化输出异常信息*/
        if(head == null){
            System.out.println("错误：链表未初始化！");
            return ;
        }
        head= null ;
    }
    /**
     * @see list.List#clear()
     * @explain clear方法:清空双向链表
     * @throws 
     * @author 叶清逸
     * @date 2018年7月24日 下午7:40:53
     */
    @Override
    public void clear() {
        /*若未初始化输出异常信息*/
        if(head == null){
            System.out.println("错误：链表未初始化！");
            return ;
        }
        head.next = null ;
        head.prior = null ;
    }
    /**
     * @see list.List#length()
     * @explain length方法:获取双向链表长度
     * @return 链表的长度
     * @throws 
     * @author 叶清逸
     * @date 2018年7月24日 下午7:03:23
     */
    @Override
    public int length() {
        /*若未初始化输出异常信息*/
        if(head == null){
            System.out.println("错误：链表未初始化！");
            return -1;
        }

        return LENGTH ;
    }
    /**
     * @see list.List#get(int)
     * @explain get方法:获取缩影位置的元素
     * @param index 索引
     * @return
     * @throws 
     * @author 叶清逸
     * @date 2018年7月24日 下午7:41:15
     */
    @Override
    public Object get(int index) {
        /*若未初始化输出异常信息*/
        if(head == null){
            System.out.println("错误：链表未初始化！");
            return null;
        }
        /*判断index是否合法*/
        if(index > LENGTH || index<=0){
            System.out.println("错误：索引不合法！");
            return null;
        }
        Element p = head.next ;
        /*找到索引位置*/
        for(int i=0 ; i<index-1 ; i++){
            p = p.next ;
        }
        return p.data;
    }
    /**
     * @see list.List#locateElem(java.lang.Object)
     * @explain locateElem方法:获取元素的索引
     * @param elem  元素
     * @return  元素的索引位置,若未找到则返回-1
     * @throws 
     * @author 叶清逸
     * @date 2018年7月24日 下午7:49:42
     */
    @Override
    public int locateElem(Object elem) {
        /*若未初始化输出异常信息*/
        if(head == null){
            System.out.println("错误：链表未初始化！");
            return -1;
        }

        int index = -1 ;
        /*遍历找到元素的位置*/
        Element p = head.next ;
        for(int i=0 ; i<LENGTH ; i++){
            if(p.data.equals(elem)){
                return i+1 ;
            }
            p = p.next ;
        }
        return index ;
    }
    /**
     * @see list.List#priorElem(java.lang.Object)
     * @explain priorElem方法:获取元素的前驱
     * @param elem 元素
     * @return 元素的前驱
     * @throws 
     * @author 叶清逸
     * @date 2018年7月24日 下午7:57:03
     */
    @Override
    public Object priorElem(Object elem) {
        /*若未初始化输出异常信息*/
        if(head == null){
            System.out.println("错误：链表未初始化！");
            return null;
        }

        Element prior = null ;
        /*定位到元素*/
        Element p = head.next ;
        while(p != null){
            if(p.data.equals(elem)){
                break ;
            }
            p = p.next ;
        }
        /*获取前驱*/
        if(p != null){
            prior = p.prior ;
            return prior.data;
        }else{
            return null ;
        }
    }

    @Override
    public Object nextElem(Object elem) {
        /*若未初始化输出异常信息*/
        if(head == null){
            System.out.println("错误：链表未初始化！");
            return null;
        }
        Element next = null ;
        /*定位到元素*/
        Element p = head.next ;
        while(p != null){
            if(p.data.equals(elem)){
                break ;
            }
            p = p.next ;
        }
        if(p.next != null){
            next = p.next ;
            return next.data;
        }else{
            return null ;
        }
    }
    /**
     * @see list.List#put(java.lang.Object)
     * @explain put方法:添加元素
     * @param elem 要添加的元素
     * @throws 
     * @author 叶清逸
     * @date 2018年7月24日 下午7:04:06
     */
    @Override
    public void put(Object elem) {
        /*若未初始化输出异常信息*/
        if(head == null){
            System.out.println("错误：链表未初始化！");
            return ;
        }
        /*申请空间将元素存入*/
        Element e = new Element() ;
        e.data = elem ;
        /*遍历找出要插入的位置*/
        Element p = head ;
        while(p.next != null){
            p = p.next ;
        }
        /*改变指针指向*/
        e.next = p.next ;
        e.prior = p ;
        p.next = e ;

        LENGTH++ ;
    }
    /**
     * @see list.List#insert(int, java.lang.Object)
     * @explain insert方法:在索引位置插入元素
     * @param index 索引
     * @param elem 要插入的元素
     * @throws 
     * @author 叶清逸
     * @date 2018年7月24日 下午8:14:43
     */
    @Override
    public void insert(int index, Object elem) {
        /*若未初始化输出异常信息*/
        if(head == null){
            System.out.println("错误：链表未初始化！");
            return ;
        }
        /*判断index是否合法*/
        if(index > LENGTH || index<=0){
            System.out.println("错误：索引不合法！");
            return ;
        }
        /*找到索引位置*/
        Element p = head ;
        for(int i=0 ; i<index-1 ; i++){
            p = p.next ;
        }
        /*插入元素*/
        Element e = new Element() ;
        e.data = elem ;
        e.next = p.next ;
        e.prior = p ;
        p.next = e ;
        e.next.prior = e ;

        LENGTH++ ;
    }
    /**
     * @see list.List#replace(int, java.lang.Object)
     * @explain replace方法:将索引位置的元素替换为传入元素
     * @param index 索引位置
     * @param elem 替换的元素
     * @throws 
     * @author 叶清逸
     * @date 2018年7月24日 下午9:43:46
     */
    @Override
    public void replace(int index, Object elem) {
        /*若未初始化输出异常信息*/
        if(head == null){
            System.out.println("错误：链表未初始化！");
            return ;
        }
        /*判断index是否合法*/
        if(index > LENGTH || index<=0){
            System.out.println("错误：索引不合法！");
            return ;
        }
        /*找到索引位置*/
        Element p = head ;
        for(int i=0 ; i<index ; i++){
            p = p.next ;
        }
        /*替换元素*/
        p.data = elem ;
    }

    @Override
    public void delete(int index) {
        /*若未初始化输出异常信息*/
        if(head == null){
            System.out.println("错误：链表未初始化！");
            return ;
        }
        /*判断index是否合法*/
        if(index > LENGTH || index<=0){
            System.out.println("错误：索引不合法！");
            return ;
        }
        /*找到索引位置*/
        Element p = head ;
        for(int i=0 ; i<index-1 ; i++){
            p = p.next ;
        }
        /*删除元素*/
        p.next = p.next.next ;
        p.next.prior = p ;

        LENGTH-- ;
    }
    /**
     * @see list.List#isEmpty()
     * @explain isEmpty方法:判断链表是否为空
     * @return 返回Boolean类型值，true为空，false为非空
     * @throws 
     * @author 叶清逸
     * @date 2018年7月24日 下午9:52:53
     */
    @Override
    public boolean isEmpty() {
        boolean flag = false ;

        /*判断是否为空*/
        if(head.next == null)
            flag = true ;

        return flag;
    }
    /**
     * @see list.List#print()
     * @explain print方法:打印链表，顺序访问各个节点
     * @throws 
     * @author 叶清逸
     * @date 2018年7月24日 下午9:55:34
     */
    @Override
    public void print() {
        /*若未初始化输出异常信息*/
        if(head == null){
            System.out.println("错误：链表未初始化！");
            return ;
        }
        /*顺序访问各节点*/
        Element p = head.next ;
        while(p != null){
            System.out.print(p.data+" ");
            p = p.next ;
        }
        System.out.println();
    }
    @Override
    public String toString() {
        String str = "DouLinkList:[" ;
        Element p = head.next ;
        while(p != null){
            if(p.next != null){
                str = str + p.data +"," ;
                p = p.next ;
            }else{
                str = str + p.data ;
                p = p.next ;
            }

        }
        str = str+"]" ;
        return str ;
    }

}
叶清逸
关注
专栏目录
数据结构——双向链表（Java实现）
Hydra的博客
08-30 489
链表的节点 一个链表的节点(Node)分为两部分，第一部data分保存节点本身的数据，第二部分存储下一个节点地址。 最后一个节点存储的下一个节点的地址为空。单向链表，只提供从链表头插入节点。 使用内部类构造节点 private class Node{//使用内部类构造节点 private Object val;//节点数据 private Node next;//节点指针，指向...
数据结构-链表结构-双向链表
陆卿之的博客
08-01 3826
双向链表
JAVA实现双向链表
热门推荐
冯立彬的博客
04-19 4万+
                                        JAVA实现双向链表其实java.util.LinkedList就是一个双链表：public class DoubleLinkedList{  // 节点类Node  private static class Node  {    Object value;    Node prev = this;   
Java-双向链表的实现
最新发布
Broken_x的博客
09-10 475
双向链表是一种灵活且高效的数据结构，它通过每个节点中的前后指针，使得在链表中的任意位置进行插入和删除操作变得简单。希望对你有所帮助。
线性链表的双向链表——java实现
weixin_30412167的博客
02-21 112
.线性表链式存储结构:将采用一组地址的任意的存储单元存放线性表中的数据元素。 链表又可分为： 单链表：每个节点只保留一个引用，该引用指向当前节点的下一个节点，没有引用指向头结点，尾节点的next引用为null。 循环链表：一种首尾相连的链表。 双向链表：每个节点有两个引用，一个指向当前节点的上一个节点，另外一个指向当前节点的下一个节点。 ...
数据结构之双向链表详细（java版）
夏夜凉月
05-23 623
前言 双向链表是一种线性表，常见的线性表还有单向链表、栈、队列，本篇主要是分析双向链表的结构，以及如何使用java自己实现一个双向链表。 1、单向链表 在分析双向链表前，有必要先看看单向链表的结构图，方便对比双向链表数据结构。 ...
Java数据结构 双向链表
Zack_orz的博客
09-28 409
Java数据结构 双向链表 单链表       单向链表，它包含两个域，一个信息域和一个指针域。这个链接指向表中的下一个节点，而最后一个节点则指向一个空值NULL。单向链表只可向一个方向遍历。       单链表的一个优点是结构简单，但是它也有一个缺点，即在单链表中只能通过一...
doublelink.zip_DoubleLink java_双向链表实现
09-24
在本文中，我们将深入探讨如何使用Java编程语言实现一个高效的双向链表数据结构，并通过测试用例进行验证。首先，让我们了解双向链表的基本概念。 双向链表是一种线性数据结构，其中每个节点包含两个指针，分别指向...
数据结构之双向链表的Java实现.doc
10-01
在数据结构中，双向链表是一种重要的线性数据结构，它允许我们从前向后或从后向前遍历元素。相较于单链表，双向链表每个节点包含两个指针，一个指向前一个节点（previous），另一个指向后一个节点（next）。这种设计...
Java实现双向链表
03-22
用Java定义一个双向链表，实现链表的基本操作： 初始化、获取头结点、添加新元素、删除链表元素、 获取链表元素、查找链表元素、更新链表中某个元素、 判断链表是否为空、求链表元素个数、输出链表元素、清空链表。
数据结构之双向链表详解
小源_ 的博客
12-20 3650
本文着重讲解了LinkedList(无头双向单链表)的实现和LinkedList的使用。内附代码和图文分析，看完就会！
java数据结构——双向链表
一杯清泉
08-11 626
链表是非常常见的一类线性结构的数据结构，每个节点包含有指针域和数据域，常见的包括单项列表、双向列表、循环列表。这篇文章将详细介绍双向链表。 双端链表不同于单向链表仅有一个指针域指向下一个节点，而是同时持有下一个和上一个指针域，分别指向下一个和上一个节点，如下： 本文将介绍双向链表的插入节点、根据位置插入节点、删除头结点、删除尾节点、删除指定位置节点，查看链表元素、查看头结点、查看尾节点、查...
数据结构之双向链表（JAVA实现）
Android developer.
07-28 4398
最近重新复习了一些基础的数据结构，发觉自己好多已经淡忘了，索性重新捡起来以前的知识，今天笔者回顾了一下链表的知识，用JAVA实现了一个双向链表，下面来看代码：public class DoubleLinkedList { // 节点类Node private static class Node { Object value; No
Java数据结构--双向链表
m0_74808313的博客
04-23 1883
在上一篇中我们学习了单向链表的实现，链表中我们除了单向链表还有双向链表，在这一篇我们将更进一步地了解链表，实现双向链表。
Java数据结构之双向链表
qq15035899256的博客
07-05 1872
双向遍历，既可以从前向后遍历，也可以从后往前遍历。(工作中常用) 优点：可以找到前驱和后继，可进可退；缺点：增加删除节点复杂，需要多分配一个指针存储空间。
Java数据结构与算法——双向链表
★★光亭★★
03-11 6177
Java数据结构与算法——双向链表
数据结构之双向链表（java版）
wang_hahah的博客
07-01 239
为什么需要双向链表？ 单链表的结点都只有一个指向下一个结点，单链表的数据元素无法直接访问其前驱元素，所以逆序访问单链表中元素极其耗时； 思想有点类似使用空间复杂度换时间复杂度。 双向链表：在单链表的结点中增加一个指向其前驱的pre指针；该链表中第一个结点的前趋结点为NULL，最后一个结点的后继结点为NULL 。 双向链表具有单链表的所有操作：添加元素、插入元素、删除元素、遍历元素； 双向链表应用实例 使用带head头的双向链表实现 –水浒英雄排行榜 管理单向链表的缺点分析: 单向链表，查找的方向只能是
java 双向链表结构_Java 数据结构 双向链表
weixin_28753113的博客
03-07 211
Java 数据结构 双向链表基本特点单向链表：只有指向下一个结点的引用(后驱)双向链表：既有指向下一个结点的引用(后驱)，也有指向上一个结点的引用(前驱)优点双向链表在查找元素的时候，速度比之单向链表会更快拥有前驱后驱，操作更灵活缺点增加删除结点操作更繁琐一些占用的资源更多，数据存储率相比单向链表更低(生产中使用单链表比双链表更多)存储结构在这里插入图片描述Java代码package linkli...
数据结构之双向链表（Java实现）
regens的博客
03-20 609
数据结构之双向链表（Java实习）
数据结构深入解析：双向链表与Java实现
这个课件旨在帮助学生理解双向链表和其他数据结构的概念，通过学习Java语言来描述数据结构，并培养良好的学习习惯和方法。学生可以通过阅读推荐的教材，结合课程内容，深入理解和掌握数据结构的知识。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值