java双向链表数据怎么存储到数据库

目录

• 一、在双向链表的尾部添加节点数据的思路分析示意图
• 二、删除双向链表节点数据的思路分析示意图
• 三、双向链表（Double Linked List）的修改、删除、查询及在双向链表尾部添加节点的代码示例

一、在双向链表的尾部添加节点数据的思路分析示意图

二、删除双向链表节点数据的思路分析示意图

三、双向链表（Double Linked List）的修改、删除、查询及在双向链表尾部添加节点的代码示例

1、定义一个人员节点类，每一个PersonNode对象就是一个节点

package com.rf.springboot01.dataStructure.doubleLinkedList;

/**
 * @description: 定义一个人员节点类，每一个PersonNode对象就是一个节点
 * @author: xiaozhi
 * @create: 2020-07-22 21:22
 */
public class PersonNode2 {
    public int num;//编号
    public String name;//名称
    public String aliasName;//别名
    public PersonNode2 next;//指向下一个节点，默认为null
    public PersonNode2 pre;//指前一个节点，默认为null

    //构造器
    public PersonNode2(int num, String name, String aliasName) {
        this.num = num;
        this.name = name;
        this.aliasName = aliasName;
    }

    //重写toString方法
    @Override
    public String toString() {
        return "PersonNode{" +
                "num=" + num +
                ", name='" + name + '\'' +
                ", aliasName='" + aliasName + '\'' +
                '}';
    }
}

2、创建一个双向链表管理人员节点

package com.rf.springboot01.dataStructure.doubleLinkedList;


/**
 * @description: 创建一个双向链表管理人员节点
 * @author: xiaozhi
 * @create: 2020-07-22 21:07
 */
public class DoubleLinkedList {

    //先初始化一个头结点，头节点位置固定，不存放任何数据，作用是表示链表的头节点
    private PersonNode2 head =new PersonNode2(0,"","");

    public PersonNode2 getHead() {
        return head;
    }
    /** 
    * @Description: 添加节点到双向链表最后，（不考虑编号顺序）,找到当前双向链表的最后节点进行添加
    * @Param:  
    * @Author: xz  
    * @return: 
    * @Date: 2020/7/22 21:28  
    */
    public void insertDoubleLinkedList(PersonNode2 personNode2){
        //因为头节点不能动，所以需要一个临时变量来遍历
        PersonNode2 temp=head;
        //遍历双向链表
        while(true){
            //判断是否到双向链表最后
            if(temp.next == null){
                break;
            }
            //将temp向后移动
            temp = temp.next;
        }
        //当退出while循环时，temp就指向了链表的最后
        //将最后这个节点temp的next指向新的节点,新节点的pre指向最后个节点temp
        temp.next=personNode2;
        personNode2.pre=temp;
    }

    /** 
    * @Description: 修改双向链表的节点
    * @Param:  
    * @Author: xz  
    * @return: 
    * @Date: 2020/7/22 21:34  
    */
    public void updateDoubleLinkedList(PersonNode2 personNode2){
        if(head.next==null){
            System.out.println("链表为空");
            return;
        }
        //找到需要修改的节点，根据num修改
        PersonNode2 temp=head.next;
        boolean flag=false;//表示是否找到需要修改的节点编号，默认已找到
        while(true){
            if(temp==null){
                break;//表示已遍历完链表
            }
            if(temp.num==personNode2.num){//已找到需要修改的节点编号
                flag=true;
                break;
            }
            temp=temp.next;
        }
        if(flag){//已找到需要修改的节点编号
            temp.name=personNode2.name;
            temp.aliasName=personNode2.aliasName;
        }else{
            System.out.printf("没有找到 编号%d的节点,不能修改\n",personNode2.num);
        }
    }
    /** 
    * @Description: 删除双向链表中的一个节点
    * @Param:  
    * @Author: xz  
    * @return: 
    * @Date: 2020/7/22 21:47
    */
    public void deleteDoubleLinkedList(int num){
        if(head.next==null){
            System.out.println("链表为空，无法删除");
            return;
        }
        PersonNode2 temp=head.next;//定义一个辅助节点，头节点的后一个节点，即待删除的节点
        boolean flag=false;//标志是否找到待删除节点
        while(true){
            if (temp==null){//已找到链表最后节点的next域
                break;
            }
            if(temp.num==num){//找到待删除的节点
                flag=true;
                break;
            }
            temp=temp.next;//临时变量后移
        }
        if(flag){//找到待删除的节点，可以删除
            temp.pre.next=temp.next;
            //如果temp是最后一个节点，temp.next=null,会报空指针，所以需要加一个判断
            if(temp.next!=null){
                temp.next.pre=temp.pre;
            }
        }else{//没有找到待删除的节点
            System.out.printf("要删除的 d% 节点不存在",num);
        }
    }
    /** 
    * @Description: 遍历双向链表
    * @Param: [] 
    * @Author: xz  
    * @return: void
    * @Date: 2020/7/22 21:24  
    */ 
    public void selectDoubleLinkedList(){
        //因为头节点不能动，所以需要一个临时变量来遍历
        PersonNode2 temp=head.next;
        //判断链表是否为空
        if(temp==null){
            System.out.println("双向链表为空");
            return;
        }
        //遍历双向链表
        while(true){
            //判断是否到双向链表最后
            if(temp == null){
                break;
            }
            //输出节点信息
            System.out.println(temp);
            //将temp向后移动
            temp = temp.next;
        }
    }


}

3、定义一个测试类

package com.rf.springboot01.dataStructure.doubleLinkedList;

/**
 * @description: 
 * @author: xiaozhi
 * @create: 2020-07-22 21:37
 */
public class DoubleLinkedListTest {
    public static void main(String[] args) {
        //创建双向链表节点
        PersonNode2 personNode1 = new PersonNode2(1, "张三", "小张");
        PersonNode2 personNode2 = new PersonNode2(2, "李四", "小李");
        PersonNode2 personNode3 = new PersonNode2(3, "王五", "小王");
        PersonNode2 personNode4 = new PersonNode2(4, "赵二", "小赵");

        //添加双向链表节点
        System.out.println("加节点到双向链表最后，（不考虑编号顺序）==========");
        DoubleLinkedList list = new DoubleLinkedList();
        list.insertDoubleLinkedList(personNode1);
        list.insertDoubleLinkedList(personNode2);
        list.insertDoubleLinkedList(personNode3);
        list.insertDoubleLinkedList(personNode4);
        //查询双向链表节点
        list.selectDoubleLinkedList();

        System.out.println("修改编号为1的原始双向链表的节点==========");
        //创建一个双向链表节点，根据编号修改原始双向链表的节点
        PersonNode2 personNode6 = new PersonNode2(1, "java", "学习java");
        list.updateDoubleLinkedList(personNode6);
        //查询双向链表节点
        list.selectDoubleLinkedList();

        System.out.println("修改编号为4的原始双向链表的节点==========");
        list.deleteDoubleLinkedList(4);
        //查询双向链表节点
        list.selectDoubleLinkedList();

    }
}

4、运行测试类，输出结果