java实现双链表（差点没写吐系列...）

　　刚才把单链表写完了，现在又把双链表写了，双链表和单链表的区别就是每个节点有prior和next两个指针，不同于单链表的一个next指针，而且，正是因为有这两个指针，所以双链表可以前后两个方向去移动指针，

同时，我所实现的双链表和单链表不同之处在于，主要体现在其不用每次都把指针从头结点开始遍历，而是根据实际情况从选择最优的线路去遍历，移动到想要的位置。差点写吐了....话不多说，上代码

　　

package com.voole.linkedlist;

public class Test {
    public static void main(String[] args) {
//        LinkedList linkedList = new LinkedList();
//        linkedList.insert(new Node(null, null));
//        linkedList.insert(new Node(null, null));
//        linkedList.insert(new Node(null, null));
//        linkedList.insert(new Node(null, null));
//        linkedList.insert(new Node(null, null));
//        linkedList.insert(new Node(null, null),2);
//        Node node = new Node(null, null);
//        linkedList.update(node,2);
//        System.out.println(linkedList.select(2));
//        System.out.println(node);
        DoubleLinkedList doubleLinkedList = new DoubleLinkedList();
        doubleLinkedList.insert(new Node(null, null, null));
        doubleLinkedList.insert(new Node(null, null, null));
        doubleLinkedList.insert(new Node(null, null, null));
        doubleLinkedList.insert(new Node(null, null, null));
        doubleLinkedList.insert(new Node(null, null, null),3);
        doubleLinkedList.select(2);
    }
}



package com.voole.linkedlist;


/**
 * 双链表(该链表的效率比单链表高，主要体现在其不用每次都把指针从头结点开始遍历，而是根据实际情况从选择最优的线路去遍历，移动到想要的位置)
 * @author TMAC-J
 *
 */
public class DoubleLinkedList {
    /**
     * 头结点
     */
    private Node head = null;
    /**
     * 链表长度
     */
    private int size = 0;
    /**
     * 定义指针
     */
    private int point = 0;
    /**
     * 当前指针指向的节点
     */
    private Node currentNode = null;
    /**
     * 构造方法
     */
    public DoubleLinkedList(){
        head = new Node(null, null, null);
    }
    /**
     * 增(从末尾增加)
     */
    public void insert(Node node){
        if(size == 0){
            head.next = node;
            currentNode = node;
            node.prior = head;
        }
        else{
            while(point<size){
                currentNode = currentNode.next;
                point++;
            }
            currentNode.next = node;
            node.prior = currentNode;
            currentNode = node;
        }
        point++;
        size++;
        LinkedListLog.getInstance().insert();
    }
    /**
     * 增(从任意位置添加)
     */
    public void insert(Node node,int position){
        checkPosition(position);
        //如果指针离插入位置更近
        if(Math.abs(position-point)<=position){
            if((position-point)>0){
                while(point<position-1){
                    currentNode = currentNode.next;
                    point++;
                }
                node.next = currentNode.next;
                currentNode.next = node;
                node.prior = currentNode;
                currentNode = node;
            }
            else if((position-point)<=0){
                while(point>position){
                    currentNode = currentNode.prior;
                    point--;
                }
                node.prior = currentNode.prior;
                currentNode.prior = node;
                node.next = currentNode;
                currentNode = node;
            }
        }
        //如果头结点离插入位置更近
        else{
            point = 0;
            while(point<position-1){
                if(point == 0){
                    currentNode = head.next; 
                }
                else{
                    currentNode = currentNode.next;
                }
                point++;
            }
            if(currentNode!=null){
                node.next = currentNode.next;
                currentNode.next = node;
                node.prior = currentNode;
                currentNode = node;
            }
            else{
                head.next = node;
                node.prior = head;
            }
        }
        size++;
        LinkedListLog.getInstance().insert();
    }
    /**
     * 删(从末尾删除)
     */
    public void delete(){
        if(size == 0){
            LinkedListLog.getInstance().error();
            return;
        }
        while(point<size){
            currentNode = currentNode.next;
            point++;
        }
        currentNode = currentNode.prior;
        currentNode.next = null;
        point--;
        size--;
        LinkedListLog.getInstance().delete();
    }
    /**
     * 删(任意位置删除)
     */
    public void delete(int position){
        checkPosition(position);
        if(size == 0){
            LinkedListLog.getInstance().error();
            return;
        }
        //如果指针离插入位置更近
        if(Math.abs(position-point)<=position){
            if((position-point)>0){
                while(point<position-1){
                    currentNode = currentNode.next;
                    point++;
                }
                try{
                currentNode.next = currentNode.next.next;
                currentNode.next.next.prior = currentNode;
                }catch(Exception e){
                    /**
                     * 这里为了防止currentNode.next.next为空设定，
                     * 若以后发现currentNode.next.next为空的情况存在，这里在做一些措施
                     * 目前逻辑有点复杂，不想看了....等抛出再处理
                     */
                    System.out.println("有参数为空！");
                }        
            }
            else if((position-point)<=0){
                while(point>position){
                    currentNode = currentNode.prior;
                    point--;
                }
                try{
                currentNode.next.prior = currentNode.prior.next;
                currentNode.prior.next = currentNode.next.prior;
                currentNode = currentNode.next;
                }catch(Exception e){
                    /**
                     * 理由同上
                     */
                    System.out.println("有参数为空！");
                }
            }
        }
        //如果头结点离插入位置更近
        else{
            point = 0;
            while(point<position-1){
                if(point == 0){
                    currentNode = head.next; 
                }
                else{
                    currentNode = currentNode.next;
                }
                point++;
            }
            try{
                currentNode.next = currentNode.next.next;
                currentNode.next.next.prior = currentNode;
            }catch(Exception e){
                /**
                 * 理由如上
                 */
                System.out.println("参数为空！");
            }
        }
        size--;
        LinkedListLog.getInstance().delete();
    }
    /**
     * 改
     */
    public void update(Node node,int position){
        checkPosition(position);
        if(size == 0){
            LinkedListLog.getInstance().error();
            return;
        }
        //如果指针离插入位置更近
        if(Math.abs(position-point)<=position){
            if((position-point)>0){
                while(point<position-1){
                    currentNode = currentNode.next;
                    point++;
                }
                node.next = currentNode.next.next;
                node.prior = currentNode;
                currentNode.next.next.prior = node;
                currentNode.next = node;
            }
            else if((position-point)<=0){
                while(point>position){
                    currentNode = currentNode.prior;
                    point--;
                }
                node.next = currentNode.next;
                node.prior = currentNode.prior;
                currentNode.next.prior = node;
                currentNode.prior.next = node;
                currentNode = node;
            }
        }
        //如果头结点离插入位置更近
        else{
            point = 0;
            while(point<position-1){
                if(point == 0){
                    currentNode = head.next; 
                }
                else{
                    currentNode = currentNode.next;
                }
                point++;
            }
            node.next = currentNode.next.next;
            node.prior = currentNode;
            currentNode.next.next.prior = node;
            currentNode.next = node;
        }
        LinkedListLog.getInstance().update();
    }
    /**
     * 查
     */
    public Node select(int position){
        checkPosition(position);
        if(size == 0){
            LinkedListLog.getInstance().error();
            return null;
        }
        //如果指针离插入位置更近
        if(Math.abs(position-point)<=position){
            if((position-point)>0){
                while(point<position-1){
                    currentNode = currentNode.next;
                    point++;
                }
                LinkedListLog.getInstance().select();
                return currentNode.next;
            }
            else if((position-point)<=0){
                while(point>position){
                    currentNode = currentNode.prior;
                    point--;
                }
                LinkedListLog.getInstance().select();
                return currentNode;
            }
        }
        //如果头结点离插入位置更近
        else{
            point = 0;
            while(point<position-1){
                if(point == 0){
                    currentNode = head.next; 
                }
                else{
                    currentNode = currentNode.next;
                }
                point++;
            }
            LinkedListLog.getInstance().select();
            return currentNode.next;
        }
        LinkedListLog.getInstance().error();
        return null;
    }
    /**
     * 检查位置是否正确
     */
    public void checkPosition(int position){
        if(position>size+1||position<=0){
            LinkedListLog.getInstance().error();
            return;
        }
    }
}


package com.voole.linkedlist;
/**
 * @description 链表节点
 * @author TMAC-J
 *
 */
public class Node {
    /**
     * 定义下一个指针
     */
    public Node next = null;
    /**
     * 定义上一个指针
     */
    public Node prior = null;
    /**
     * 定义数据域
     */
    public Data data = null;
    /**
     * @description 构造方法
     */
    public Node(Node prior,Node next,Data data){
        this.prior = prior;
        this.next = next;
        this.data = data;
    }
}


package com.voole.linkedlist;

import java.io.Serializable;

public class Data implements Serializable{

    private static final long serialVersionUID = 1L;

}



package com.voole.linkedlist;
/**
 * 单例日志类（饿汉）
 * @author TMAC-J
 *
 */
public class LinkedListLog {
    private static final LinkedListLog instance = new LinkedListLog();
    
    private LinkedListLog(){}
    
    public static LinkedListLog getInstance(){
        return instance;
    }
    
    public void insert(){
        System.out.println("插入成功！");
    }
    
    public void delete(){
        System.out.println("删除成功！");
    }
    
    public void update(){
        System.out.println("修改成功！");
    }
    
    public void select(){
        System.out.println("查询成功！");
    }
    
    public void error(){
        System.out.println("错误！");
    }
}

　　可能还会有一些小bug，以后碰到的时候再改吧，先写到这了。