Java实现双向链表

上一篇文章http://blog.csdn.net/iniegang/article/details/48932261已经对循环单链表进行了具体实现，对于双向链表，实现起来也非常类似，但是需要注意的是每个节点（除了头尾）都要分别指向它的前驱节点和后继节点。本人做了简单的实现，如下

class DNode<T>{

    private T data; //定义节点数据域
    private DNode<T> nextDNode; //定义下一个节点
    private DNode<T> preDNode; //定义前一个节点

    private DNode<T> head=null; //定义头节点
    private DNode<T> tail=null;  //定义尾节点

    public T getData() {
        return data;
    }
    public void setData(T data) {
        this.data = data;
    }
    public DNode<T> getNextDNode() {
        return nextDNode;
    }
    public void setNextDNode(DNode<T> nextDNode) {
        this.nextDNode = nextDNode;
    }
    public DNode<T> getPreDNode() {
        return preDNode;
    }
    public void setPreDNode(DNode<T> preDNode) {
        this.preDNode = preDNode;
    }

    //初始化双向链表
    public void initDoubleList(){
        head=new DNode<T>();
        head.setData(null);
        head.setNextDNode(null);
        head.setPreDNode(null);

        tail=new DNode<T>();
        tail.setData(null);
        tail.setNextDNode(null);
        tail.setPreDNode(null);
    }

    //向双向链表的头部添加节点
    public void addToHead(DNode<T> node){
        if (null==head.getNextDNode()) {
            head.setNextDNode(node);
            tail.setPreDNode(node);
            node.setPreDNode(head);
            node.setNextDNode(tail);
        }else {
            node.setNextDNode(head.getNextDNode());
            head.getNextDNode().setPreDNode(node);
            head.setNextDNode(node);
            node.setPreDNode(head);
        }
    }

    //向双向链表的尾部添加节点
    public void addToTail(DNode<T> node){
        if (null==tail.getPreDNode()) {
            node.setNextDNode(tail);
            tail.setPreDNode(node);
            head.setNextDNode(node);
            node.setPreDNode(head);
        }else {
            tail.getPreDNode().setNextDNode(node);
            node.setPreDNode(tail.getPreDNode());
            tail.setPreDNode(node);
            node.setNextDNode(tail);
        }
    }

    //判断双向链表是否为空
    public Boolean isEmpty(){
        if (null==head.getNextDNode()||null==tail.getPreDNode()) {
            return true;
        }else {
            return false;
        }
    }

    //打印双向链表，从头指针开始
    public void printDoubleListFromHead(){
        System.out.println("从前往后");
        if (isEmpty()) {
            System.out.println("空链表");
        }else {
            DNode<T> temp=head;
            while (null!=temp.getNextDNode().getData()) {
                temp=temp.getNextDNode();
                System.out.print(temp.getData()+" ");
            }
            System.out.println();
        }
    }

    //打印双向链表，从尾指针开始
    public void printDoubleListFromTail(){
        System.out.println("从后往前");
        if (isEmpty()) {
            System.out.println("空链表");
        }else {
            DNode<T> temp=tail;
            while (null!=temp.getPreDNode().getData()) {
                temp=temp.getPreDNode();
                System.out.print(temp.getData()+" ");
            }
            System.out.println();
        }
    }

}

main函数中的测试代码如下：

public class DoubleList {

    public static void main(String[] args){
        DNode<Integer> testDNode=new DNode<Integer>();
        testDNode.initDoubleList();
        for (int i = 0; i < 5; i++) {
            DNode<Integer> node=new DNode<Integer>();
            node.setData(i);
//          testDNode.addToHead(node);
            testDNode.addToTail(node);
        }

        testDNode.printDoubleListFromHead();
        testDNode.printDoubleListFromTail();

    }

以上仅仅是我个人对双向链表的理解，有任何疏漏之处欢迎在评论区指明，谢谢！

标记为原创的博文均为本人辛苦码字所得，谢绝抄袭，转载请注明出处，新浪微博私信艾特：http://weibo.com/nieganghust