JAVA实现双向链表的增删功能

最新推荐文章于 2024-05-12 09:58:07 发布
最新推荐文章于 2024-05-12 09:58:07 发布
阅读量1.5k 收藏 1
点赞数

JAVA实现双向链表的增删功能，完整代码

复制代码 
package linked;

class LinkedTable{
    
}
public class LinkedTableTest {
    
    //构造单链表
    static Node node1 = new Node("name1");
    static Node node2 = new Node("name2");
    static Node node3 = new Node("name3");
    static Node node4 = new Node("name4");
    static Node node5 = new Node("name5");
    
    
    public static void main(String[] args)
    {
        //设置指针
        setPoint();
        
        //循环遍历
        System.out.println("*******初始链表*******");
        out(node1,node5);
        System.out.println();
        
        //插入节点在node2的后面
        addNode(node2,node3);
        
        // 循环遍历
        System.out.println("*******插入node2.5*******");
        out(node1, node5);
        System.out.println();
                
        //删除节点
        node2.setNextNode(node3);
        node3.setNextNodeF(node2);
        
        // 循环遍历
        System.out.println("*******删除node2.5*******");
        out(node1, node5);
        System.out.println();
        
    }
    
    //设置指针
    public static void setPoint()
    {
        //设置正向指针
        node1.setNextNode(node2);
        node2.setNextNode(node3);
        node3.setNextNode(node4);
        node4.setNextNode(node5);
        //设置反向指针
        node5.setNextNodeF(node4);
        node4.setNextNodeF(node3);
        node3.setNextNodeF(node2);
        node2.setNextNodeF(node1);
    }
    
    //循环遍历单链表
    public static void outLinked(Node startNode){
        Node node= new Node();
        node.setNextNode(startNode);
        do
        {
            node=node.getNextNode();
            System.out.print(node.getName()+"----");    
        }while(node.getNextNode()!=null);
    }
    
    //反向循环遍历单链表
    public static void outLinkedF(Node endNode){
        Node node= new Node();
        node.setNextNodeF(endNode);
        do
        {
            node=node.getNextNodeF();
            System.out.print(node.getName()+"----");    
        }while(node.getNextNodeF()!=null);
    }
    
    //循环遍历
    public static void out(Node startNode,Node endNode)
    {
        
        outLinked(startNode);
        System.out.println();
        outLinkedF(endNode);
        
    }
    
    //插入节点
    public static void addNode(Node preNode,Node nextNode)
    {
        Node node_add = new Node("name2.5");
        node_add.setNextNode(preNode.getNextNode());
        preNode.setNextNode(node_add);
        
        node_add.setNextNodeF(nextNode.getNextNodeF());
        nextNode.setNextNodeF(node_add);
    }
    
    

    
}


class Node {
    private String name;
    private Node nextNode;
    private Node nextNodeF;
    public void setName(String name)
    {
        this.name=name;
    }
    public void setNextNode(Node nextNode)
    {
        this.nextNode=nextNode;
    }
    public void setNextNodeF(Node nextNodeF)
    {
        this.nextNodeF=nextNodeF;
    }
    public String getName()
    {
        return this.name;
    }
    public Node getNextNode()
    {
        return this.nextNode;
    }
    public Node getNextNodeF()
    {
        return this.nextNodeF;
    }
    public Node(String name)
    {
        this.name=name;
        this.nextNode=null;
    }
    public Node( )
    {
        
    }
    
}
复制代码

1，构造node节点，需要两个指针，一个正向存储下一个元素的位置，一个反向存储下一个元素的位置

参数说明：

　　name:用于存储node自身的信息

　　nextNode:用于存储正向指针

　　nextNodeF:用于存储反向指针

复制代码 
class Node {
    private String name;
    private Node nextNode;
    private Node nextNodeF;
    public void setName(String name)
    {
        this.name=name;
    }
    public void setNextNode(Node nextNode)
    {
        this.nextNode=nextNode;
    }
    public void setNextNodeF(Node nextNodeF)
    {
        this.nextNodeF=nextNodeF;
    }
    public String getName()
    {
        return this.name;
    }
    public Node getNextNode()
    {
        return this.nextNode;
    }
    public Node getNextNodeF()
    {
        return this.nextNodeF;
    }
    public Node(String name)
    {
        this.name=name;
        this.nextNode=null;
    }
    public Node( )
    {
        
    }
    
}
复制代码

2，创建节点，设置指针连接节点

正向指针：指向下一个节点

反向节点：指向上一个节点

复制代码 
//构造单链表
    static Node node1 = new Node("name1");
    static Node node2 = new Node("name2");
    static Node node3 = new Node("name3");
    static Node node4 = new Node("name4");
    static Node node5 = new Node("name5");
复制代码
复制代码 
public static void setPoint()
    {
        //设置正向指针
        node1.setNextNode(node2);
        node2.setNextNode(node3);
        node3.setNextNode(node4);
        node4.setNextNode(node5);
        //设置反向指针
        node5.setNextNodeF(node4);
        node4.setNextNodeF(node3);
        node3.setNextNodeF(node2);
        node2.setNextNodeF(node1);
    }
复制代码

3，将链表循环遍历输出

复制代码 
public static void outLinked(Node startNode){
        Node node= new Node();
        node.setNextNode(startNode);
        do
        {
            node=node.getNextNode();
            System.out.print(node.getName()+"----");    
        }while(node.getNextNode()!=null);
    }
复制代码
复制代码 
    public static void outLinkedF(Node endNode){
        Node node= new Node();
        node.setNextNodeF(endNode);
        do
        {
            node=node.getNextNodeF();
            System.out.print(node.getName()+"----");    
        }while(node.getNextNodeF()!=null);
    }
复制代码

4，添加节点

复制代码 
    public static void addNode(Node preNode,Node nextNode)
    {
        Node node_add = new Node("name2.5");
        node_add.setNextNode(preNode.getNextNode());
        preNode.setNextNode(node_add);
        
        node_add.setNextNodeF(nextNode.getNextNodeF());
        nextNode.setNextNodeF(node_add);
    }
复制代码

5，删除节点

node2.setNextNode(node3);
node3.setNextNodeF(node2);

 

 

class Node {private String name;private Node nextNode;private Node nextNodeF;public void setName(String name){this.name=name;}public void setNextNode(Node nextNode){this.nextNode=nextNode;}public void setNextNodeF(Node nextNodeF){this.nextNodeF=nextNodeF;}public String getName(){return this.name;}public Node getNextNode(){return this.nextNode;}public Node getNextNodeF(){return this.nextNodeF;}public Node(String name){this.name=name;this.nextNode=null;}public Node( ){}}

http://www.ayp2545.cn/
http://www.pgn4393.cn/
http://www.npd9270.cn/
http://www.sfi6002.cn/
http://www.nne5492.cn/
http://www.yai2320.cn/
http://www.ics4171.cn/
http://www.sfv9051.cn/
http://www.ccg1407.cn/
http://www.hjn1455.cn/
http://www.ygf6271.cn/
http://www.vfm1218.cn/
http://www.aaa4131.cn/
http://www.guc5469.cn/
http://www.dcj3647.cn/
http://www.utm9669.cn/
http://www.ahg7671.cn/
http://www.nxn1651.cn/
http://www.rrq5757.cn/
http://www.pbr1256.cn/
http://www.oai3459.cn/
http://www.vaj6107.cn/
http://www.xfc0942.cn/
http://www.evc2128.cn/
http://www.bwu7749.cn/
http://www.rmf4655.cn/
http://www.pyq8206.cn/
http://www.sdk5229.cn/
http://www.sez8143.cn/
http://www.tfn8353.cn/
http://www.uem3051.cn/
http://www.tza5452.cn/
http://www.epp9269.cn/
http://www.tsr7510.cn/
http://www.xhv3734.cn/
http://www.vrc9998.cn/
http://www.dsf5404.cn/
http://www.xjm6385.cn/
http://www.iaz1229.cn/
http://www.kcv6320.cn/
http://www.usl0022.cn/
http://www.abo8793.cn/
http://www.qeb9677.cn/
http://www.atx6995.cn/
http://www.buv6436.cn/
http://www.lll4952.cn/
http://www.cjx5965.cn/
http://www.otg2660.cn/
http://www.bmn9515.cn/
http://www.ewf1466.cn/
http://www.cbc3788.cn/
http://www.iqp5694.cn/
http://www.drr8954.cn/
http://www.blk2293.cn/
http://www.tjx3222.cn/
http://www.ksy2010.cn/
kkfd1002
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java实现双向链表
keke的博客
10-07 3826
Java实现双向链表
【JAVA】双向链表详解
weixin_74999790的博客
06-04 3134
LinkedList的底层是双向链表结构(链表后面介绍)，由于链表没有将元素存储在连续的空间中，元素存储在单独的节点中，然后通过引用将节点连接起来了，因此在在任意位置插入或者删除元素时，不需要搬移元素，效率比较高。每个数据节点都有两个指针，指向前驱和后继，所以，双向链表中的任意一个节点开始，都可以十分方便找到前驱节点和后继节点。
【Java数据结构】傻瓜都懂的双向链表，你值得阅读（附详细图解和源代码）
最新发布
2401_84558508的博客
05-12 447
学完之后，若是想验收效果如何，其实最好的方法就是可自己去总结一下。比如我就会在学习完一个东西之后自己去手绘一份xmind文件的知识梳理大纲脑图，这样也可方便后续的复习，且都是自己的理解，相信随便瞟几眼就能迅速过完整个知识，脑补回来。下方即为我手绘的MyBtis知识脑图，由于是xmind文件，不好上传，所以小编将其以图片形式导出来传在此处，细节方面不是特别清晰。但可给感兴趣的朋友提供完整的MyBtis知识脑图原件（包括上方的面试解析xmind文档）
【数据结构】Java实现双向链表
qq_53869058的博客
03-20 1939
LinkedList的底层是双向链表结构，由于链表没有将元素存储在连续的空间中，元素存储在单独的节点中，然后通过引用将节点连接起来了，因此在在任意位置插入或者删除元素时，不需要搬移元素，效率比较高。
java实现双向链表(图解以及分析)
qq_54469537的博客
10-02 1841
详细分析以图解实现双向链表
一步步带你用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语言实现双向链表（增删查）
wifiiii的博客
04-26 87
节点对象 public class Node<T> { public T value; public Node pre = null; public Node next = null; public Node(T value, Node pre, Node next) { this.value = value; this.pre = pre; this.next = next; } } 双向链表 publ
java数据结构，双向链表的实现
m0_63622279的博客
11-22 497
双向链表也叫双链表，是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。DoubleListNode.java为结构体类，DoubleLinkedList.java为实现类，MyList.java为方法接口。设置head和last两个哑元（其数据域并不存放数据），只是为了方便插入删除。双链表，需要一个指向前驱的指针，后指向后继元素的指针，以及数据域。插入的话，需要修改四个指针指向（修改顺序具有一定的规则！
Java数据结构——代码实现双向链表的方法
chenchenchencl的博客
09-23 2445
一文速学双向链表方法的实现
java实现双向链表
qq_53933886的博客
10-08 347
java原生实现双向链表
Java 实现 双向链表
m0_52066789的博客
01-06 3883
在上篇文章中介绍了怎么使用 java 代码编写一个自己的单链表，那么接下来就又来介绍下双链表的实现。 Java代码实现单链表：Java实现 单链表_m0_52066789的博客-CSDN博客 目录 1.双链表 1.1 双链表的基本框架 1.2 头节点实体类（ListNode） 1.3 双向链表实体类（DoubleLinkedList） 1.3.1 头插法 — addFirst（int data） 1.3.2 尾插法 —addLast（int data） 1.3.3 根据下标插入新的节..
链表之Java实现双向链表
Shen_Dong的博客
03-24 503
定义：链式存储结构的特点是用一组任意的存储单元存储线性表的 数据元素，这组存储单元可以是连续的，也可以是不连续的。物理存储结构如下：图中每一个节点均代表存储的数据，并且都包含该节点的下一个节点的位置信息。
Java数据结构--双向链表
m0_74808313的博客
04-23 1644
在上一篇中我们学习了单向链表的实现，链表中我们除了单向链表还有双向链表，在这一篇我们将更进一步地了解链表，实现双向链表。
数据结构 (JAVA)：链表(2)_双向链表（构造、头插、尾插、中间插入、删除等操作及实现代码）
2301_80653026的博客
04-13 1185
双向链表在于Link类中，多了一个Pre前驱链接，相对于单链表只有next链接，需要弄清楚前驱和后驱的链接关系可以选择固定headt和last节点，插入或者删除first或者last节点，只需要修改2个链接在链表中间插入链接，需要修改4个链接（第一步一定是把要插入的节点先连接上）；在链表中间删除，只需要修改2个链接，一定要通过画图来更好的理解链接的关系。
Java基础--LinkedList类实现链表
weixin_67679565的博客
01-29 770
Java基础，链表基础，LinkedList类实现链表。
【双向链表】java代码实现
m0_58097299的博客
01-22 2680
【双向链表】java代码实现，图文详解，带大家去掌握双向链表知识。
Java中的双向链表
weixin_54043141的博客
11-12 52
双向链表是由节点组成的数据结构，每个节点包含两个部分：数据和指向前一个节点和后一个节点的引用。它相对于单向链表的优势在于能够方便地从前向后或从后向前遍历。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值