java实现双向链表

public class DoubleLinkList {
    private Node head;  //链表头结点
    private Node tail;   //链表尾结点
    int size=1;
    //初始化链表 
    public DoubleLinkList(int data) {
        // TODO Auto-generated constructor stub
        head=new Node(null, 1, null);
        tail=head;
    }
    //链表是否为空
    public boolean isEmpty() {
        return size==0; 
    }
    //获得双向链表的长度
    public int  getSize() {
        return size;
    }
    //获得指定位置的节点，index从0开始 计算
    public Node getNode(int index) {
        if (index<0||index>size-1) {
            throw new IndexOutOfBoundsException("索引越界");        
        }else {
            int a=0;
            Node current=head;
            while (index!=a) {      
            current=current.next;
            a++;
            }
            //结束循环后current 指向index位置的节点
            return current;
        }           
    }
    //获得指定位置节点的数据
    public int  getData(int index) {
        return getNode(index).data;
    }
    //在链表的头部位置插入节点
    public void  addHeadData(int data) {
        Node node=new Node(null, data, this.head);
         this.head.pre=node;
         this.head=node;
         if (tail==null) {
            this.head=tail;
        }
         size++;
    }
    //在尾部位置插入节点
    public void  addTailData(int data) {
        if (head==null) {
            head=new Node(null, data, null);
            this.tail=this.head;
        }else {
            Node node =new Node(tail, data, null); 
           tail.next=node;
            tail=node;
        }
        size++;

    }
    //在指定位置插入节点
    public void  addData(int index ,int data) {
        if (index<0||index>size) {
            throw new IndexOutOfBoundsException("索引越界");
        }else {
            if (head==null) {
                this.addTailData(data);   //尾部插入
            }else {
                if (index==0) {
                    this.addHeadData(data);
                }else {
                    Node node=this.getNode(index-1);  //要先找到插入的前一个节点
                    Node current=node.next;
                    Node newNode=new Node(node, data, current);
                    //newNode.pre=node,newNode.next=current;
                    node.next=newNode;
                    current.pre=newNode;
                    size++;
                }
            }
        }
    }
    //删除尾结点
    public void  deleteTail() {
        Node node=this.getNode(size-2);
        Node current=node.next;    //要删除的节点
        node.next=current.next;
        current.next=null;
        current.pre=null;      
       size--;
    }
    //删除指定位置节点
    public void delete(int index) {
        //System.out.println(size-1);
        if (index<0||index>size-1)
        throw new IndexOutOfBoundsException("索引越界");
        //删除的是头结点
        if (index==0) {
            Node current=head;
            this.head=head.next;
            this.head.pre=null;
            size--;
        }else {
            Node node=this.getNode(index-1);
            Node current=node.next;    //要删除的节点
            node.next=current.next;
            if (current.next!=null)    //如果是尾结点
                   current.next.pre=node;
            else {
                current.next=null;
                current.pre=null;              
            size--;
            }
        }               
    }
    //正向打印链表
    public void  print() {  
        for(Node node=head;node!=null;node=node.next)
        {
            System.out.print(node.data +"  ");
        }
        System.out.println();
    }
    //反向打印链表
    public void  reversePrint() {
        for (Node node=tail;node!=null;node=node.pre) {
            System.out.print(node.data+"  ");
        }
        System.out.println();
    }
    //链表的结点类
    class Node{
           int data;
           Node pre;
           Node next;
           public Node(Node pre,int data,Node next) {
            // TODO Auto-generated constructor stub
                this.pre=pre;
                this.data=data;
                this.next=next;
        }
    }

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        DoubleLinkList list=new DoubleLinkList(1);
        for (int i=0;i<6;i++) {
            list.addTailData(i);
        }
        System.out.println("正向打印链表");
        list.print();
        System.out.println("插入头结点后打印链表");
        list.addHeadData(20);
        list.print();
        System.out.println("插入尾结点后打印链表");
        list.addTailData(30);
        list.print();
        list.addData(2, 10);
        System.out.println("插入数据后正向打印链表");
        list.print();
        list.delete(0);
        System.out.println("删除头结点后正向打印链表 ");
        list.print();
        list.deleteTail();
        System.out.println("删除尾结点后正向打印链表 ");
        list.print();
        list.delete(3);
        System.out.println("删除索引为3的数据后打印链表");
        list.print();
        //list.reversePrint();

    }

}

结果

正向打印链表
1 0 1 2 3 4 5
插入头结点后打印链表
20 1 0 1 2 3 4 5
插入尾结点后打印链表
20 1 0 1 2 3 4 5 30
插入数据后正向打印链表
20 1 10 0 1 2 3 4 5 30
删除头结点后正向打印链表
1 10 0 1 2 3 4 5 30
删除尾结点后正向打印链表
1 10 0 1 2 3 4 5
删除索引为3的数据后打印链表
1 10 0 2 3 4 5