Java模拟单向链表和双向链表的实现

下面演示的Java模拟的单向链表的实现

1. package com.jadyer.sort;  
2.   
3. /** 
4.  * 模拟单向链表 
5.  * @author hope
6.  * @editor Jan 23, 2012 7:55:21 PM 
7.  * @see ================================================================================================== 
8.  * @see 【数据结构的分类：线性数据结构和非线性数据结构】 
9.  * @see 1)线性数据结构，包含：线性表、栈、队列、串、数组、文件 
10.  * @see 2)非线性数据结构，含：树、图 
11.  * @see ================================================================================================== 
12.  * @see 【线性表的概述：其数据元素呈线性关系】 
13.  * @see 1)线性表中的所有数据元素在同一个线性表中必须是相同的数据类型 
14.  * @see 2)线性表中必存在唯一的称为"第一个"的数据元素，必存在唯一的称为"最后一个"的数据元素 
15.  * @see 3)线性表中除第一个元素外，每个元素都有且只有一个前驱元素。除最后一个元素外，每个元素都有且只有一个后继元素 
16.  * @see 4)线性表的逻辑结构是n个数据元素的有限序列(a1,a2,a3,...,an)，其中n为线性表的长度(n>=0)，n=0的表称为空表 
17.  * @see ================================================================================================== 
18.  * @see 【线性表的分类：按其存储结构可分为顺序表和链表】 
19.  * @see 1)顺序表：用顺序存储结构存储的线性表称为顺序表。即内存地址中的元素是按照循序连续存放的 
20.  * @see          也可以说，将线性表中的数据元素依次存放在某个存储区域中，所形成的表称为顺序表 
21.  * @see          一维数组就是用顺序方式存储的线性表，所以ArrayList可以看作是一种顺序表 
22.  * @see 2)链表：用链式存储结构存储的线性表称为链表。即内存地址中的元素不是连续存放的 
23.  * @see ================================================================================================== 
24.  * @see 【stack】 
25.  * @see 栈(stack)也是一种特殊的线性表，是限定仅在表尾进行插入和删除运算的线性表 
26.  * @see 栈的物理存储可以用顺序存储结构，也可以用链式存储结构 
27.  * @see 栈是一种后进先出(LIFO)的结构，栈的表尾称为栈顶(top)，栈的表头称为栈底(bottom) 
28.  * @see ================================================================================================== 
29.  * @see 【Queue】 
30.  * @see 队列(Queue)是限定所有的插入只能在表的一端进行，而所有的删除都在表的另一端进行的线性表 
31.  * @see 队列的物理存储可以用顺序存储结构，也可以用链式存储结构  
32.  * @see 队列是一种先进先出(FIFO)的结构，其中允许插入的一端称为队尾(Rear)，允许删除的一端称为队头(Front)(有点像等公交车) 
33.  * @see ================================================================================================== 
34.  */  
35. class NodeOneWay {  
36.     String data; //存放节点数据本身   
37.     NodeOneWay next;   //存放指向后一个节点的引用   
38.       
39.     public NodeOneWay(){}  
40.       
41.     public NodeOneWay(String data){  
42.         this.data = data;  
43.     }  
44. }  
45.   
46.   
47. /** 
48.  * 单向链表测试类 
49.  * @author 宏宇 
50.  * @editor Jan 23, 2012 7:56:51 PM 
51.  */  
52. public class NodeOneWayTest {  
53.     public static void main(String[] args) {  
54.         NodeOneWay node11 = new NodeOneWay("node11_data");  
55.         NodeOneWay node22 = new NodeOneWay("node22_data");  
56.         NodeOneWay node33 = new NodeOneWay("node33_data");  
57.         node11.next = node22; //生成后继关系   
58.         node22.next = node33;  
59.         System.out.println(node11.next.next.data); //通过node11获得node33的data属性值   
60.         /** 
61.          * 生成node44对象，并将其插入到node11和node22中间 
62.          */  
63.         NodeOneWay node44 = new NodeOneWay("node44_data");  
64.         node11.next = node44; //修改node11的后继关系指向node44   
65.         node44.next = node22; //修改node44的后继关系指向node22   
66.         System.out.println(node11.next.next.next.data); //通过node11获得node33的data属性值   
67.         System.out.println(node11.next.next.data);      //通过node11获得node22的data属性值   
68.         /** 
69.          * 删除node44对象 
70.          */  
71.         node11.next = node22; //即node11的后继关系指向node22，node44的后继关系不再指向node22   
72.         node44.next = null;  
73.         System.out.println(node11.next.next.data); //通过node11获得node33的data属性值   
74.     }  
75. }  

下面演示的是Java模拟双向链表的实现

1. package com.jadyer.sort;  
2.   
3. /** 
4.  * 模拟双向循环链表 
5.  * @author hope
6.  * @editor Jan 23, 2012 8:16:34 PM 
7.  * @see java.util.ArrayList类的底层，是用数组实现的 
8.  * @see java.util.LinkedList类的底层，就是用双向循环链表实现的 
9.  * @see 双向链表内的每个对象除了数据本身外，还有两个引用，分别指向前一个元素和后一个元素 
10.  * @see 故add/remove操作时，LinkedList性能好一些，而get操作时，ArrayList性能好一些 
11.  */  
12. class NodeTwoWay {  
13.     NodeTwoWay previous; //存放指向前一个节点的引用   
14.     String data;     //存放节点数据本身   
15.     NodeTwoWay next;     //存放指向后一个节点的引用   
16.       
17.     public NodeTwoWay(){}  
18.       
19.     public NodeTwoWay(String data){  
20.         this.data = data;  
21.     }  
22. }  
23.   
24.   
25. /** 
26.  * 双向循环链表测试类 
27.  * @author 宏宇 
28.  * @editor Jan 23, 2012 8:21:33 PM 
29.  */  
30. public class NodeTwoWayTest {  
31.     public static void main(String[] args) {  
32.         NodeTwoWay node11 = new NodeTwoWay("node11_data");  
33.         NodeTwoWay node22 = new NodeTwoWay("node22_data");  
34.         NodeTwoWay node33 = new NodeTwoWay("node33_data");  
35.         node11.previous = node33; //生成前驱和后继关系   
36.         node11.next = node22;  
37.         node22.previous = node11;  
38.         node22.next = node33;  
39.         node33.previous = node22;  
40.         node33.next = node11;  
41.         /** 
42.          * 生成node44对象，并将其插入到node11和node22中间 
43.          */  
44.         NodeTwoWay node44 = new NodeTwoWay("node44_data");  
45.         node44.previous = node11;  
46.         node44.next = node22;  
47.         node11.next = node44;  
48.         node22.previous = node44;  
49.         /** 
50.          * 删除node44对象 
51.          */  
52.         node44.previous = null;  
53.         node44.next = null;  
54.         node11.next = node22;  
55.         node22.previous = node11;  
56.     }  
57. }