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

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

1. packagecom.jadyer.sort;
3. /**
4. *模拟单向链表
5. *@author hope
6. *@editorJan23,20127:55:21PM
7. *@see==================================================================================================
8. *@see【数据结构的分类：线性数据结构和非线性数据结构】
9. *@see1)线性数据结构，包含：线性表、栈、队列、串、数组、文件
10. *@see2)非线性数据结构，含：树、图
11. *@see==================================================================================================
12. *@see【线性表的概述：其数据元素呈线性关系】
13. *@see1)线性表中的所有数据元素在同一个线性表中必须是相同的数据类型
14. *@see2)线性表中必存在唯一的称为"第一个"的数据元素，必存在唯一的称为"最后一个"的数据元素
15. *@see3)线性表中除第一个元素外，每个元素都有且只有一个前驱元素。除最后一个元素外，每个元素都有且只有一个后继元素
16. *@see4)线性表的逻辑结构是n个数据元素的有限序列(a1,a2,a3,...,an)，其中n为线性表的长度(n>=0)，n=0的表称为空表
17. *@see==================================================================================================
18. *@see【线性表的分类：按其存储结构可分为顺序表和链表】
19. *@see1)顺序表：用顺序存储结构存储的线性表称为顺序表。即内存地址中的元素是按照循序连续存放的
20. *@see也可以说，将线性表中的数据元素依次存放在某个存储区域中，所形成的表称为顺序表
21. *@see一维数组就是用顺序方式存储的线性表，所以ArrayList可以看作是一种顺序表
22. *@see2)链表：用链式存储结构存储的线性表称为链表。即内存地址中的元素不是连续存放的
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. classNodeOneWay{
36. Stringdata;//存放节点数据本身
37. NodeOneWaynext;//存放指向后一个节点的引用
39. publicNodeOneWay(){}
41. publicNodeOneWay(Stringdata){
42. this.data=data;
43. }
44. }
47. /**
48. *单向链表测试类
49. *@author宏宇
50. *@editorJan23,20127:56:51PM
51. */
52. publicclassNodeOneWayTest{
53. publicstaticvoidmain(String[]args){
54. NodeOneWaynode11=newNodeOneWay("node11_data");
55. NodeOneWaynode22=newNodeOneWay("node22_data");
56. NodeOneWaynode33=newNodeOneWay("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. NodeOneWaynode44=newNodeOneWay("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. packagecom.jadyer.sort;
3. /**
4. *模拟双向循环链表
5. *@author hope
6. *@editorJan23,20128:16:34PM
7. *@seejava.util.ArrayList类的底层，是用数组实现的
8. *@seejava.util.LinkedList类的底层，就是用双向循环链表实现的
9. *@see双向链表内的每个对象除了数据本身外，还有两个引用，分别指向前一个元素和后一个元素
10. *@see故add/remove操作时，LinkedList性能好一些，而get操作时，ArrayList性能好一些
11. */
12. classNodeTwoWay{
13. NodeTwoWayprevious;//存放指向前一个节点的引用
14. Stringdata;//存放节点数据本身
15. NodeTwoWaynext;//存放指向后一个节点的引用
17. publicNodeTwoWay(){}
19. publicNodeTwoWay(Stringdata){
20. this.data=data;
21. }
22. }
25. /**
26. *双向循环链表测试类
27. *@author宏宇
28. *@editorJan23,20128:21:33PM
29. */
30. publicclassNodeTwoWayTest{
31. publicstaticvoidmain(String[]args){
32. NodeTwoWaynode11=newNodeTwoWay("node11_data");
33. NodeTwoWaynode22=newNodeTwoWay("node22_data");
34. NodeTwoWaynode33=newNodeTwoWay("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. NodeTwoWaynode44=newNodeTwoWay("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. }