java 双向链表的示例

已于 2023-02-24 23:50:25 修改
阅读量393 收藏
点赞数
分类专栏： 数据结构 文章标签： java 链表 数据结构
于 2022-10-11 17:37:37 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dai510131/article/details/127268068
版权

  一、简介

  双向链表在查询数据时有一个优势，就是在查询数据时并不像单向链表那样要从头到尾的查，而是可以在链表的某一中间的某一个数据向前或向后查询其它数据，使查询时间进一步缩短了那么一点点。

  二、双向链表的示例代码如下：

/**
  * 包名：linkedlist
  *  文件名：DoubleLinkedListDemo.java
  *  
  * 功能：双链表数据结构的增删改查
  *
  * 作者：冰雪青松
  * 邮箱：946585434@qq.com
  * 日期：2022.10.13
  *
  **/
package linkedlist;

import java.util.*;

/**
  *  一、主类，即入口类，
  *
  * 说明：是对双向链表数据结构的操作，是次要的类
  *
  **/
public class DoubleLinkedListDemo {
    public static void main(String[] args) {
      
        DoubleLinkedList doubleLinkedList = new DoubleLinkedList();
      
 //########## ［ 对双向链表的增删改查的操作  ］######################
 //------------------------------------------------------------------------------------------------------------------------------
 // 1.遍历二维数组添加数据进双向链表 begin
 
      //建立数据的二维数组
        String[][] nameArr = {
            {"宋江", "卢俊义", "吴用", "林冲", "公孙胜", "关胜", "秦明", "公孙胜", "呼延灼", "花荣"}, 
            {"及时雨", "玉麒麟", "智多星", "豹子头", "入云龙", "大刀", "霹雳火", "入云龙", "双鞭", "小李广"}
        };
       
        //编号，排序依据此偏号，可修改编号查看排序情况
        int[] noArr = {1, 9, 2, 5, 8, 10, 4, 3, 7, 6};
       
        //true 不排序；false 排序
        boolean tag = false;
       
        //遍历二维数组添加节点进链表
        if(tag){
            //按输入顺序进链表
            for(int i = 0; i < nameArr[0].length; i++){
                doubleLinkedList.add(new DHeroNode(noArr[i] , nameArr[0][i], nameArr[1][i]));
             }
        }else{
             //按排序进链表
            for(int i = 0; i < nameArr[0].length; i++){
                doubleLinkedList.addByOrder(new DHeroNode(noArr[i], nameArr[0][i], nameArr[1][i]));
            }
        }
      
        System.out.println("--------------------------------------");
        System.out.println("一、双向链表添加数据：\n");
      
        //遍历显示
        doubleLinkedList.list();
      
        System.out.println("--------------------------------------");
            
 // 1.遍历二维数组添加数据进双向链表  end.
 //------------------------------------------------------------------------------------------------------------------------------
 // 2.修改双向链表  begin
      
        int upNo1 = 2;
        String upName1 = "孙悟空";
        String upNick1    = "齐天大圣";
      
        int upNo2 = 6;
        String upName2 = "猪八戒";
        String upNick2    = "花心大萝卜";
      
        System.out.printf("\n二、准备修改的内容：\n\n编号：%d，姓名：%s，绰号：%s", upNo1, upName1, upNick1);
        System.out.printf("\n编号：%d，姓名：%s，绰号：%s", upNo2, upName2, upNick2);
        System.out.println("\n\n修改后的数据：\n");
        doubleLinkedList.update(new DHeroNode(upNo1, upName1, upNick1));
        doubleLinkedList.update(new DHeroNode(upNo2, upName2, upNick2));
      
        //遍历显示
        doubleLinkedList.list();
      
        System.out.println("--------------------------------------");
      
 // 2.修改双向链表  end.
 //------------------------------------------------------------------------------------------------------------------------------
 // 3.删除双向链表的节点  begin
 
        int n1 = 2;
        int n2 = 6;
      
        System.out.printf("三、要删除的编号为：%d 和 %d\n\n", n1, n2);
        doubleLinkedList.delete(n1);
        doubleLinkedList.delete(n2);
      
        System.out.println("删除后的数据：\n");
        
        //遍历显示
        doubleLinkedList.list();
        System.out.println("--------------------------------------");
      
 // 3.删除双向链表的节点  end.
 //------------------------------------------------------------------------------------------------------------------------------
 // 4.添加双向链表的节点  begin
      
        String[][] addArr = {
            {"鲁智深", "武松"}, 
            {"花和尚", "行者"}
         };

        System.out.printf("\n四、要添加的数据为：\n\n编号：%d ，姓名：%s，绰号：%s\n", n1, addArr[0][0], addArr[1][0]);
        System.out.printf("编号：%d ，姓名：%s，绰号：%s\n\n", n2, addArr[0][1], addArr[1][1]);
        System.out.println("添加后的数据：\n");
        doubleLinkedList.addByOrder(new DHeroNode(n1, addArr[0][0], addArr[1][0]));
        doubleLinkedList.addByOrder(new DHeroNode(n2, addArr[0][1], addArr[1][1]));
      
        //遍历显示
        doubleLinkedList.list();
        System.out.println("--------------------------------------");
      
 // 4.添加双向链表的节点  end.
 //------------------------------------------------------------------------------------------------------------------------------
 // 5.查询双向链表的一个节点  begin
     
        int qn = 9;  //要查询的位置
     
        System.out.printf("五、要查询的编号为：%d\n\n", qn);
        String[] strArr = doubleLinkedList.query(qn);
     
        if(strArr[0] == "" && strArr[1] == ""){
            System.out.println("error!");
        }else{
            System.out.printf("编号：%d，姓名：%s，绰号：%s\n\n", qn, strArr[0], strArr[1]);
        }
        
        System.out.println("--------------------------------------");

 // 5.查询双向链表的一个节点  end.
 //------------------------------------------------------------------------------------------------------------------------------
 // 6.查询双向链表的一个节点的上一节点的数据，检验双链表是否成功  begin
 
        int qn1 = 8;  //要查询的位置
        
        System.out.printf("六、查询的编号为 %d 的前一数据，\n\t\t\t\t检验双向链表是否成功！\n\n", qn1);
        String[] strArr1 = doubleLinkedList.queryPrev(qn1);
     
        if(strArr1[0] == "" && strArr1[1] == ""){
            System.out.println("error!");
        }else{
            System.out.printf("编号：%d，姓名：%s，绰号：%s\n\n", qn1, strArr1[0], strArr1[1]);
        }
      
 // 6.查询双向链表的一个节点的上一节点的数据，检验双链表是否成功  end.
  //------------------------------------------------------------------------------------------------------------------------------
 //##########################################################
    }
}

/**
  * 二、链表管理类
  *
  *  说明：对双向链表数据结构的算法类，重要的操作类！
  *
  */
class DoubleLinkedList{
    
    //申请一个空白的头节点
    private DHeroNode head = new DHeroNode(0, "", "");
    
    /**
      * 功能：按输入顺序添加
      *
      *  说明：按输入顺序添加数据进双向链表
      *
      * @param DHeroNode heroNode  要添加的数据节点
      * @return void
      **/
    public void add(DHeroNode heroNode){
         DHeroNode temp = head;
         boolean flag = false;
        
         while(true){
              if(temp.next == null) break;
              if(temp.next.no == heroNode.no) flag = true;
              temp = temp.next;
          }
          
          if(flag){
              System.out.printf("编号为%d的数据己经存在！\n", heroNode.no);
              return;
          }else{
              temp.next = heroNode;
              heroNode.prev = temp;
          }
    }
    
    /**
      * 功能：按排序顺序添加
      *
      *  说明：按排序顺序添加数据进双向链表
      *
      * @param DHeroNode heroNode  要添加的数据节点
      * @return void
      **/
    public void addByOrder(DHeroNode heroNode){
         DHeroNode temp = head;
         boolean flag = false;
        
         while(true){
             if(temp.next == null)
                  break;
             else if(temp.next.no > heroNode.no)
                  break;
             else if(temp.next.no == heroNode.no)
                  flag = true;
                
             temp = temp.next;
        }
        
        if(flag){
            System.out.printf("编号为%d的数据已经存在！\n", heroNode.no);
            return;
        }else{
            heroNode.next = temp.next;
            temp.next = heroNode;
            heroNode.prev = temp;
            
            if(heroNode.next != null)
                heroNode.next.prev = heroNode;
        }
    }
        
    /**
      * 功能：修改双向链表的数据
      *
      * @param DHeroNode heroNode  要修改的数据节点
      * @return boolean     返回 true 成功或 false 失败的信息
      **/
    public boolean update(DHeroNode newNode){
          
          if(head.next == null){
              System.out.println("双向链表为空！");
              return false;
          }
          
          DHeroNode temp = head;
          boolean flag = false;
          
          while(true){
              
              if(temp.next == null)
                  break;
              else if(temp.next.no == newNode.no){
                  flag = true;
                  
                  break;
              }
              
              temp = temp.next;
          }
          
          if(flag){
              temp.next.name = newNode.name;
              temp.next.nickname = newNode.nickname;
          }else{
              System.out.printf("没有找到编号为%d的数据！\n", newNode.no);
          }
          
          return true;
    }
    
    /**
      * 功能：删除双向链表的一个节点
      *
      * @param int n   要删除的数据位置
      * @return boolean  返回 true 成功或 false 失败的信息
      **/
    public boolean delete(int n){
        DHeroNode temp = head;
        boolean flag = false;
        
        if(head.next == null){
            System.out.println("链表为空！");
            return false;
        }
        
        while(true){
            
            if(temp.next == null)
                break;
                
            if(temp.next.no == n){
                flag = true;
                break;
            }
            
            temp = temp.next;
        }
        
        if(flag){
            temp.next = temp.next.next;
            
            if(temp.next != null)
                temp.next.prev = temp;
                
            return true;
        }else{
            System.out.printf("编号为%d的数据不存在！", n);
        }
        
        return false;
    }

    /**
      * 功能：查询某一节点的数据
      *
      * @param int n   要查询的数据位置
      * @return String[]  返回  error 空数组或有数据数组的信息
      **/
    public String[] query(int n){
        String[] error = {"", ""};
            
        if(head.next == null){
            System.out.println("链表为空！");
            return error;
        }
        
        DHeroNode temp = head.next;
        boolean flag = false;
        
        while(true){
            
            if(temp.next == null) break;
            
            if(temp.next.no == n){
                flag = true;
                break;
            }
            
            temp = temp.next;
        }
        
        if(temp.next != null)
            temp = temp.next;
        
        if(flag){
            String[] tmp = {temp.name, temp.nickname};
                return tmp;
        }else{
            System.out.printf("编号为%d的数据不存在！", n);
            return error;
        }
    }
    
    /**
      * 功能：查询某一节点的后一数据
      *
      * 说明：检验双向链表是否成功
      *
      * @param int n   要查询的数据位置
      * @return String[]  返回  error 空数组或有数据数组的信息
      **/
    public String[] queryPrev(int n){
        String[] error = {"", ""};
            
        if(head.next == null){
            System.out.println("链表为空！");
            return error;
        }
        
        DHeroNode temp = head.next;
        boolean flag = false;
        
        while(true){
            
            if(temp.next == null) break;
            
            if(temp.next.no == n){
                flag = true;
                break;
            }
            
            temp = temp.next;
        }
        
        if(temp.next != null)
            temp = temp.next;
        
        if(flag){
            String[] tmp = {temp.prev.name, temp.prev.nickname};
                return tmp;
        }else{
            System.out.printf("编号为%d的数据不存在！", n);
            return error;
        }
    }
    
    /**
      * 功能：遍历显示数据
      *
      * @param none
      * @return void
      **/
    public void list(){
        if(head.next == null){
            System.out.println("链表为空！");
            return;
        }
        
        DHeroNode temp = head.next;
        
        while(true){
            if(temp == null) break;
            System.out.println(temp);
            temp = temp.next;
        }
    }
}

/**
  * 三、双向链表的数据结构节点
  *
  * 说明：是重要的数据类
  *
  **/
class DHeroNode{
    public int no;
    public String name;
    public String nickname;
    public DHeroNode prev;  //previous
    public DHeroNode next;
    
    public DHeroNode(int no, String name, String nickname){
        this.no = no;
        this.name = name;
        this.nickname = nickname;
    }
    
    @Override
    public String toString(){
        String str1 = "", str2 = "";
        
        //由于界面显示混乱，排版
        switch(name.length()){
            case 1: str1 = "，．．．绰号：" ;break;
            case 2: str1 = "，．．绰号：" ;break;
            case 3: str1 = "，‍．绰号：" ;break;
            case 4: str1 = "，绰号：" ;break;
            default: str1 = "，绰号：" ;
        }
        
        //由于界面显示混乱，排版
        if(no < 10)
            str2 = "， 姓名：" ;
        else if(no >= 10 && no < 100)
            str2 = "，姓名：" ;
        else if(no >= 100)
            str2 = "，姓名：" ;
            
        return "编号：" + no + str2 + name + str1 + nickname;
    }
}

  三、程序执行后的效果：

  1.检验双向链表是否成功？

8df97c78b5164ad080c6e0443ef7a0bb.jpeg

  2.完整的效果：

8e22ea07f3dd40cb80f0d8d992b50023.jpeg

冰雪青松
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
java 环形链表的示例
孤舟残月梦还长存的专栏
10-15 605
环形链表是解决像约瑟夫环问题的类似问题的求解。
Java双向链表的实现
Become hunger become strong
03-03 166
Java双向链表的实现 定义：双向链表中的数据结点有两个指针，分别指向直接后继和直接前驱，所以从双向链表中的任一结点开始，都可以很方便的访问它的前驱结点和后继结点。 链表节点的定义 在单向链表定义的前提下添加pre，表示指向当前节点的前一个。 class PersonNode { // number是值，从小到大；可以根据需要调节 public int number; public String name; public String nickName; publ
JAVA双向链表反转实现
06-10
通过java实现的双向链表，及反转功能，可能对面试有用哦
【双向链表】java代码实现
m0_58097299的博客
01-22 2672
【双向链表】java代码实现，图文详解，带大家去掌握双向链表知识。
【Java数据结构】傻瓜都懂的双向链表，你值得阅读（附详细图解和源代码）
最新发布
2401_84558508的博客
05-12 433
学完之后，若是想验收效果如何，其实最好的方法就是可自己去总结一下。比如我就会在学习完一个东西之后自己去手绘一份xmind文件的知识梳理大纲脑图，这样也可方便后续的复习，且都是自己的理解，相信随便瞟几眼就能迅速过完整个知识，脑补回来。下方即为我手绘的MyBtis知识脑图，由于是xmind文件，不好上传，所以小编将其以图片形式导出来传在此处，细节方面不是特别清晰。但可给感兴趣的朋友提供完整的MyBtis知识脑图原件（包括上方的面试解析xmind文档）
Java实现双向链表
keke的博客
10-07 3797
Java实现双向链表
一步步带你用Java实现双向链表（超详细）
热门推荐
you do ,you win
04-21 1万+
文章目录什么是双向链表属性及方法节点Nodesize数据插入头插法 addFirst(T value)尾插法 addLast(T value)插入到指定下标位置add(int index)数据删除(返回被删除节点存储的值)删除头结点 removeFirst删除尾结点 removeLast删除指定下标节点remove（int index）获取指定下标位置节点的数据 getData（int index）获取链表长度遍历输出print()详细遍历输出清空链表实现细节 上一节说到了单链表,这一节我们来手写一个双向链
Java数据结构--双向链表
m0_74808313的博客
04-23 1608
在上一篇中我们学习了单向链表的实现，链表中我们除了单向链表还有双向链表，在这一篇我们将更进一步地了解链表，实现双向链表。
java实现单链表、双向链表
09-02
本示例中，我们分别讨论了两种类型的链表：单链表和双向链表。 单链表由一系列节点组成，每个节点包含一个数据字段和一个指向下一个节点的引用。在Java中，我们可以创建一个`Node`类来表示单链表的节点： ```java ...
java数据结构之实现双向链表的示例
09-04
本示例将详细介绍如何在Java中实现一个简单的双向链表，并提供相关的操作方法。 双向链表由一系列节点组成，每个节点包含三个主要部分：数据（存储实际信息）、前驱节点引用（指向前面的节点）和后继节点引用（指向...
PHP双向链表定义与用法示例
12-20
在给定的示例中，我们看到一个实现了双向链表的PHP代码，包括节点类`Node_Element`和链表类`DoubleLinkedList`。 **双向链表定义** 双向链表由一系列节点组成，每个节点包含三个主要部分：数据（`data`）、前驱（`...
java基于双向环形链表解决丢手帕问题的方法示例
08-28
Java基于双向环形链表解决丢手帕问题的方法示例 Java基于双向环形链表解决丢手帕问题的方法示例主要介绍了如何使用Java语言来解决丢手帕问题。丢手帕问题是一个经典的算法问题，描述了小孩围坐一圈，按顺序报数，...
【Java数据结构与算法】双向链表
12-21
在Java中实现双向链表，通常会定义一个包含数据和指针的节点类，如`HeroNode2`，并创建一个`DoubleLinkedList`类来管理链表。`DoubleLinkedList`类通常包括构造函数、遍历方法、添加方法、更新方法和删除方法。在给...
Java数据结构之双向链表（配图详解，简单易懂）
如风暖阳的博客
01-28 5671
Java数据结构之双向链表（配图详解，简单易懂）
链表之Java实现双向链表
Shen_Dong的博客
03-24 501
定义：链式存储结构的特点是用一组任意的存储单元存储线性表的 数据元素，这组存储单元可以是连续的，也可以是不连续的。物理存储结构如下：图中每一个节点均代表存储的数据，并且都包含该节点的下一个节点的位置信息。
【数据结构】Java实现双向链表
qq_53869058的博客
03-20 1926
LinkedList的底层是双向链表结构，由于链表没有将元素存储在连续的空间中，元素存储在单独的节点中，然后通过引用将节点连接起来了，因此在在任意位置插入或者删除元素时，不需要搬移元素，效率比较高。
【Java数据结构】链表(Linked List)-双向链表
yubao0723的专栏
04-15 795
使用Java实现简单的双向链表
Java-双向链表的实现
xhmico的博客
04-03 1038
双向链表也称为双链表，是链表的一种，它的每个数据节点都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个节点开始，都可以很方便地访问它的前驱节点和后继节点。可以使用一个head和tail分别指向头部和尾部的节点每个节点由三部分组成：前一个节点的指针prev保存的元素data后一个节点的指针next双向链表的第一个节点的 pre 是 null双向链表的最后一个节点的 next 是 null双向链表在进行增加和删除元素的时候，只需要改变prev和next的指向即可完成相关的操作。
【Java 数据结构】双向链表
程序猿教你打篮球的博客
11-16 2513
本期主要讲解： 1、什么是双向链表 2、实现一个双向链表 2.1 实现前的约定 2.2 addFirst 方法 2.3 addLast 方法 2.4 addIndex 方法 2.5 contains 方法 2.6 removeAllKey 方法 3、LinkedList 的学习 3.1认识下 LinkedList 3.2 LinkedList 的构造方法 3.3 LinkedList 的遍历 4、ArrayList 和 LinkedList的区别
JAVA 双向链表
10-10
在Java中实现双向链表需要定义一个节点类，节点类中包含一个数据项和两个指针，分别指向前一个节点和后一个节点。下面是一个简单的Java代码示例： ```java class Node { int data; Node prev; Node next; ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

冰雪青松

你的鼓励将是我创作的最大动力

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

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

打赏作者

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

抵扣说明：

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

余额充值