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，以后碰到的时候再改吧，先写到这了。