带头结点和尾节点的双向链表的（增删改查，头遍历，尾遍历）java实现

废话不多说，请看代码

测试输出

代码

package com.coderman.dataStruct;

/**
 * 双链表
 *
 * @Author zhangyukang
 * @Date 2020/2/18 19:00
 * @Version 1.0
 **/
class DoubleLinkedList {

    //代表头结点
    private DoubleLinkedNode head = new DoubleLinkedNode(null, null, null);

    //代表尾节点
    private DoubleLinkedNode tail=new DoubleLinkedNode(null,null,null);

    /**
     * 添加节点
     * @param node
     */
    public void add(DoubleLinkedNode node) {
        if (head.next == null) {
            //表示没有节点
            head.next = node;
            node.pre = head;
            tail=node;
        } else {
            //找到最后一个节点，将其添加在尾部
            DoubleLinkedNode temp = head.next;
            while(true){
                if(temp.next==null){
                    break;
                }
                temp=temp.next;
            }
            //此时temp指向的是最后一个节点，将新的节点添加到其后面
            temp.next=node;
            node.pre=temp;
            tail=node;
        }
    }

    /**
     * 插入节点（根据位置，position从1开始）
     * @param node
     * @param position
     */
    public void insert(DoubleLinkedNode node,int position){
        if(checkPosition(position)){
            //找到该位置的节点
            DoubleLinkedNode temp=head;
            for(int i = 0; i<position;i++){
                temp=temp.next;
            }
            //此时temp执行的是该位置节点
            DoubleLinkedNode prNode=temp.pre;
            DoubleLinkedNode curNode=temp;
            node.pre=prNode;
            prNode.next=node;
            curNode.pre=node;
            node.next=curNode;
        }else {
            System.out.println("输入的下标不合法");
        }
    }

    /**
     * 删除节点
     * @param position
     */
    public void delete(int position){
        if(checkPosition(position)){
            //找到要删除的这个节点
            DoubleLinkedNode temp=head;
            for(int i = 0; i<position;i++){
                temp=temp.next;
            }
            //此时temp执行的是该位置节点
            if(temp.next==null){
                //如果删除的是尾节点
                tail=temp.pre;
                tail.next=null;
            }else {
                DoubleLinkedNode prNode=temp.pre;
                DoubleLinkedNode nextNode=temp.next;
                prNode.next=nextNode;
                nextNode.pre=prNode;
            }
            temp.pre=null;//help gc
            temp.next=null;//help gc

        }else {
            System.out.println("删除节点位置不合法");
        }
    }

    /**
     * 修改节点
     * @param node
     * @param position
     */
    public void update(DoubleLinkedNode node,int position){
        if(checkPosition(position)){
            //找到要删除的这个节点
            DoubleLinkedNode temp=head;
            for(int i = 0; i<position;i++){
                temp=temp.next;
            }
            //此时temp执行的是该位置节点

            if(temp.next==null){
                //如果修改的是尾节点
                node.pre=temp.pre;
                node.next=null;
                temp.pre.next=node;
                tail=node;
            }else {
                DoubleLinkedNode prNode=temp.pre;
                DoubleLinkedNode nextNode=temp.next;

                prNode.next=node;
                nextNode.pre=prNode;
                node.next=nextNode;
                nextNode.pre=node;
            }


            temp.pre=null;//help gc
            temp.next=null;//help gc
        }
    }

    /**
     * 判断位置是否合法
     * @param position
     */
    private boolean checkPosition(int position) {
        return !(position<1||position>getLength());
    }

    /**
     * 链表的长度
     * @return
     */
    public int getLength(){
        int count=0;
        if(head.next==null){
            return count;
        }else {
            DoubleLinkedNode temp=head.next;
            while (true){
                if(temp==null){
                    break;
                }
                count++;
                temp=temp.next;
            }
        }
        return count;
    }


    /**
     * 打印节点(从头节点遍历)
     */
    public void listFromHead(){
        DoubleLinkedNode temp=head.next;
        if(temp==null){
            System.out.println("双链表为空");
        }else {
            for(;temp!=null;temp=temp.next){
                System.out.print(temp.data+"\t");
            }
        }
    }

    /**
     * 打印节点(从尾节点遍历)
     */
    public void listFromTail(){
        DoubleLinkedNode temp=tail;
        if(tail.pre==null){
            System.out.println("双链表为空");
        }else {
            for(;temp.pre!=null;temp=temp.pre){
                System.out.print(temp.data+"\t");
            }
        }
    }
}

class DoubleLinkedNode {
    public Object data;
    public DoubleLinkedNode next;//后序节点
    public DoubleLinkedNode pre;//前序节点

    public DoubleLinkedNode(Object data, DoubleLinkedNode next, DoubleLinkedNode pre) {
        this.data = data;
        this.next = next;
        this.pre = pre;
    }
    public DoubleLinkedNode(Object data) {
        this.data = data;
    }
}

测试一下

public class TestDoubleLinkedList {
    public static void main(String[] args) {
        DoubleLinkedList doubleLinkedList = new DoubleLinkedList();
        doubleLinkedList.add(new DoubleLinkedNode(1));
        doubleLinkedList.add(new DoubleLinkedNode(2));
        doubleLinkedList.add(new DoubleLinkedNode(3));
        doubleLinkedList.add(new DoubleLinkedNode(4));
        doubleLinkedList.add(new DoubleLinkedNode(5));
        //插入一个节点到第二个位置
        doubleLinkedList.insert(new DoubleLinkedNode("zhang"),2);
        //更新最后一个节点
        doubleLinkedList.update(new DoubleLinkedNode("tailNode"),doubleLinkedList.getLength());
        //删除第二个节点
        doubleLinkedList.delete(4);

        System.out.println("从头部开始遍历：");
        doubleLinkedList.listFromHead();
        System.out.println();
        System.out.println("从尾部开始遍历：");
        doubleLinkedList.listFromTail();

        int length = doubleLinkedList.getLength();

        System.out.println();
        System.out.println("链表的长度是："+length);
    }
}

输出

从头部开始遍历：
1	zhang	2	4	tailNode	
从尾部开始遍历：
tailNode	4	2	zhang	1	
链表的长度是：5

Process finished with exit code 0

好像问题不大，若有问题，请评论纠正