单向链表的原理

链表是一种数据结构，和数组同级。比如，Java中我们使用的ArrayList，其实现原理是数组。而LinkedList的实现原理就是链表了。链表在进行循环遍历时效率不高，但是插入和删除时优势明显。下面对单向链表做一个介绍。

单向链表是一种线性表，实际上是由节点（Node）组成的，一个链表拥有不定数量的节点。其数据在内存中存储是不连续的，它存储的数据分散在内存中，每个结点只能也只有它能知道下一个结点的存储位置。由N各节点（Node）组成单向链表，每一个Node记录本Node的数据及下一个Node。向外暴露的只有一个头节点（Head），我们对链表的所有操作，都是直接或者间接地通过其头节点来进行的。 
 
上图中最左边的节点即为头结点（Head），但是添加节点的顺序是从右向左的，添加的新节点会被作为新节点。最先添加的节点对下一节点的引用可以为空。引用是引用下一个节点而非下一个节点的对象。因为有着不断的引用，所以头节点就可以操作所有节点了。 
下图描述了单向链表存储情况。存储是分散的，每一个节点只要记录下一节点，就把所有数据串了起来，形成了一个单向链表。 
 
节点（Node）是由一个需要储存的对象及对下一个节点的引用组成的。也就是说，节点拥有两个成员：储存的对象、对下一个节点的引用。下面图是具体的说明：

1. public class LinkedList {  
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.       
13.     public void insertFirst(Object obj){  
14.         Data data = new Data(obj);  
15.         data.next = first;  
16.         first = data;  
17.     }  
18.       
19.     public Object deleteFirst() throws Exception{  
20.         if(first == null)  
21.             throw new Exception("empty!");  
22.         Data temp = first;  
23.         first = first.next;  
24.         return temp.obj;  
25.     }  
26.       
27.     public Object find(Object obj) throws Exception{  
28.         if(first == null)  
29.             throw new Exception("LinkedList is empty!");  
30.         Data cur = first;  
31.         while(cur != null){  
32.             if(cur.obj.equals(obj)){  
33.                 return cur.obj;  
34.             }  
35.             cur = cur.next;  
36.         }  
37.         return null;  
38.     }  
39.       
40.     public void remove(Object obj) throws Exception{  
41.         if(first == null)  
42.             throw new Exception("LinkedList is empty!");  
43.         if(first.obj.equals(obj)){  
44.             first = first.next;  
45.         }else{  
46.             Data pre = first;  
47.             Data cur = first.next;  
48.             while(cur != null){  
49.                 if(cur.obj.equals(obj)){  
50.                     pre.next = cur.next;  
51.                 }  
52.                 pre = cur;  
53.                 cur = cur.next;  
54.             }  
55.         }  
56.     }  
57.       
58.     public boolean isEmpty(){  
59.         return (first == null);  
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.         LinkedList ll = new LinkedList();  
75.         ll.insertFirst(4);  
76.         ll.insertFirst(3);  
77.         ll.insertFirst(2);  
78.         ll.insertFirst(1);  
79.         ll.display();  
80.         ll.deleteFirst();  
81.         ll.display();  
82.         ll.remove(3);  
83.         ll.display();  
84.         System.out.println(ll.find(1));  
85.         System.out.println(ll.find(4));  
86.     }  
87. }