双端链表(不是双向链表)的原理

与单向链表的不同之处在保存有对最后一个链接点的引用(last)

insertFirst：在表头插入一个新的链接点，时间复杂度O(1)

insertLast：在表尾插入一个新的链接点，时间复杂度O(1)

deleteFirst：删除表头的链接点，时间复杂度O(1)

deleteLast:：删除表尾的链接点，由于只保存了表尾的链接点，而没有保存表尾的前一个链接点(这里就体现出双向链表的优势了)，所以在删除表尾链接点时需要遍历以找到表尾链接点的前一个链接点，需查找N-1次，也就是O(N)

1. public class FirstLastList {  
2.     private class Data{  
3.         private Object obj;  
4.         private Data next = null;  
5.           
6.         Data(Object obj){  
7.             this.obj = obj;  
8.         }  
9.     }  
10.       
11.     private Data first = null;  
12.     private Data last = null;  
13.       
14.     public void insertFirst(Object obj){  
15.         Data data = new Data(obj);  
16.         if(first == null)  
17.             last = data;  
18.         data.next = first;  
19.         first = data;  
20.     }  
21.       
22.     public void insertLast(Object obj){  
23.         Data data = new Data(obj);  
24.         if(first == null){  
25.             first = data;  
26.         }else{  
27.             last.next = data;  
28.   
29.         }  
30.         last = data;  
31.     }  
32.       
33.     public Object deleteFirst() throws Exception{  
34.           if(first == null)  
35.              throw new Exception("empty");  
36.           Data temp = first;  
37.           if(first.next == null)  
38.              last = null;  
39.           first = first.next;  
40.           return temp.obj;  
41.    }     
42.       
43.     public void deleteLast() throws Exception{  
44.         if(first == null)  
45.             throw new Exception("empty");  
46.         if(first.next == null){  
47.             first = null;  
48.             last = null;  
49.         }else{  
50.             Data temp = first;  
51.             while(temp.next != null){  
52.                 if(temp.next == last){  
53.                     last = temp;  
54.                     last.next = null;  
55.                     break;  
56.                 }  
57.                 temp = temp.next;  
58.             }  
59.         }  
60.     }  
61.       
62.     public void display(){  
63.         if(first == null)  
64.             System.out.println("empty");  
65.         Data cur = first;  
66.         while(cur != null){  
67.             System.out.print(cur.obj.toString() + " -> ");  
68.             cur = cur.next;  
69.         }  
70.         System.out.print("\n");  
71.     }  
72.       
73.     public static void main(String[] args) throws Exception {  
74.         FirstLastList fll = new FirstLastList();  
75.         fll.insertFirst(2);  
76.         fll.insertFirst(1);  
77.         fll.display();  
78.         fll.insertLast(3);  
79.         fll.display();  
80.         fll.deleteFirst();  
81.         fll.display();  
82.         fll.deleteLast();  
83.         fll.display();  
84.     }  
85. }