Java实现双向链表
Java实现双向链表
- 1 双向链表需求
- 2 功能及算法分析
-
- 2.1 迭代功能实现分析
- 2.2 添加元素
- 2.3 删除节点
- 3 详细设计说明
-
- 3.1 LinkIterator内部类
- 3.2 DoubleLink部分方法的实现
- 3.3 代码实现
- 4 链表的测试用例
- 5 总结
1 双向链表需求
双向链表主要在节点的构成上与单向链表略有区别，双向链表的节点拥有一个元素存储空间和两个指针域，一个指针指向下一个节点，可记为next，一个指针指向上一个节点，可记为prev。如果节点是链表的头节点，则该节点的prev为null，如果节点是尾节点，该节点的next为null。当链表中只有一个节点的时候，头节点和尾节点指向链表中的唯一节点，如下图所示。
从应用角度上来说，双向链表比单向链表的使用场景更多，操作起来也更为方便，我们常用双向链表来实现队列和栈的操作。这也是本文中，我们需要为双向链表添加的额外功能。
2 功能及算法分析
双向链表，我们依然以实现Collection为基础，这一部分我们不再进行说明，我们主要对双向链表添加的特殊方法进行说明分析。
1.public E pushFrist(E e):向链表的头结点添加新节点。
2.public E pushLast(E e):向链表的结尾处添加新节点。
3.public E popFrist():从链表的头结点取出元素，并从链表中删除该元素。
4.public E popLast():从链表的尾节点取出元素，并从链表中删除该元素。
以上这四个方法可以通过组合，达到栈和队列的效果。
5.public Iterator reIterator():获取一个反向迭代器。覆盖Collection集合的迭代器是一个正向迭代器。由于双向链表的结构特点，我们也可以从尾节点向头节点进行遍历。那么根据这个特点，在双向链表中提供一个反向迭代器用于遍历。
双向链表和单向链表在实现Collection接口的时候，有很多方法是通用的，我们几乎是可以拿来直接使用的，但下面列举的几方法，我们需要重新实现：
7.public boolean add(E e)
8.public boolean remove(Object o)
9.public void clear()
上述三个方法之所以要重写设计的原因有两个：1.单向链表和双向链表的结构有些许改变，在删除和添加的时候，涉及到了更多数据的变化。2.单向链表在删除节点的功能上留下了隐患。在双向链表中，我们在删除节点以及清空链表的时候，会采用更保险的方式进行删除。
此外getHead和getLast两个非Collection接口方法，我们也可以沿用之前的写法。
2.1 迭代功能实现分析
在双向链表中，我们可以将正向迭代器和反向迭代器合并实现。在创建迭代器对象的时候，我们通过构造方法提供几个额外的参数:
1.Node start，表示迭代的起始节点。
2.boolean isNext，初始值为true，表示迭代器的迭代方式，为true表示说明该迭代器是正向迭代器，迭代的时候用指针域的next进行迭代。否则为反向迭代器，迭代的时候用指针域的prev进行迭代。
在iterator()和reIterator()方法中我们可以通过参数来创建正反两种迭代器。
2.2 添加元素
基于add方法的添加元素，默认在链表的尾部添加节点，当添加完毕后，要更新尾节点和新节点信息，如下图所示。
add的添加方式也可以被pushLast方法所调用，它们都是从链表的尾部添加新节点。另一个添加方法pushFrist是从链表的头部添加节点，这个方法在实现的时候要注意更新头结点的指针域的信息。需要注意pushLast和pushFrist在添加成功的时候，需要将添加的新元素返回。
2.3 删除节点
在双向链表中删除节点，是影响最大的操作，当一个节点被删除的时候，要更新前一节点和后一节点的指针域信息，如下图所示。
删除的时候为了提高安全性，被删除的节点还应该清空指针域与元素存储区的数据。在双向链表的方法中，此外popLast和popFrist方法都会从链表中的两端删除节点。
此外，考虑到在删除节点的时候，有可能影响头节点和尾节点的信息，所以我们将节点删除单独封装成一个私有方法removeNode(Node node)，这样便于其它删除方法的调用。
3 详细设计说明
双向链表命名为DoubleLink泛型类，并实现Collection接口。DoubleLink的内部成员变量与单向链表一致，不做变化。DoubleLink有两个内部类，分别是LinkIterator和Node，双向链表中的Node类比单向链表中多一个成员变量Node prev，用于表示上一个节点指针域，该变量需要在Node构造方法中进行初始化赋值。
其次，为了能够自定义链表长度，我们需要额外提供一个构造方法，用于初始化链表的最大长度MAX_SIZE的值。
3.1 LinkIterator内部类
LinkIterator具体声明格式为"class LinkIterator implements Iterator"。包含的成员变量和方法如下：
-
private boolean isNext：是否正向迭代，默认值为true，构造对象时可重新赋值。
-
private Node start：遍历起始节点，通过构造方法赋值。如果提供的参数isNext为true，则start.next引用头节点，反之last.prev引用尾节点。
1. public boolean hasNext()：如果isNext为true，返回start.next!=null，如果为false，返回start.prev!=null。
2. punblic T next()：如果isNext为true，start节点后移，否则start前移。返回移动后节点的元素内容。
3.2 DoubleLink部分方法的实现
1.public DoubleLink(int linkSize):linkSize为链表最大长度的临界值，如果小于0，则默认的最大长度为2<<10。
2.public boolean add(T e):
- 方法描述：向链表中添加新元素e。返回值为true表明添加成功，失败则为false。
- 实现过程：1.先判断size>=MAX_SIZE 条件是否成立，如果成立说明超出链表长度，方法返回false，如果e为null也返回false。2.创建新节点node，其次再判断链表中是否是空链表，如果是空链表，更新头结点和尾节点信息为node。如果不是空链表，在尾节点后添加node节点，并更新尾节点和新节点的指针域信息。3.添加成功后，size自增一个单位，方法返回true。
3.private void removeNode(Node node)
- 方法描述：删除指定节点node，并更新节点前后的指针域信息。该方法是一个私有方法，会在其它方法中被多次调用。其它方法在删除节点时，不用再操作size的值。
- 实现过程: 1.如果node为null,方法结束。2.获取node的前后节点prevNode、nextNode。删除node节点（清空所有信息）,如果prevNode为null，说明node是头节点，更新头节点信息。如果nextNode为null，说明node为尾节点，更新尾节点信息。3.清空node节点成功后，size自减。
4.public void clear()
- 方法描述：清空链表信息。与单向链表设计不同，在双向链表中，我们用迭代的方式删除每一个节点，并将每一个节点的信息清除。
- 实现过程: 1.以head节点不为Null为遍历条件，使用removeNode方法移除头节点。2.遍历结束后，将head，last节点赋值空引用，size归0。
5.public boolean remove(Object o)
- 方法描述：删除链表中所有指定的元素o。
- 实现过程: 1.如果目标元素o为null,方法返回false。2.创建遍历节点node，初始值为head。3.以node!=null为条件进行遍历，在遍历的内部中，如果遍历的节点与目标o相等，删除该节点（无论是否与目标o相等，判断完毕后，node节点后移）。
6.public E pushFrist(E e)
- 方法描述：向链表的头部放入节点。
- 实现过程: 1.如果目标元素e为null,方法返回false。2.如果链表长度为0，调用并返回pushLast方法。3.创建新节点node，更新node和head节点指针域信息，size自增。
7.public E pushLast(E e)
- 方法描述：向链表的尾部放入节点。
- 实现过程: 1.如果目标元素e为null,方法返回false。2.调用add方法，如果add方法返回true，返回e,否则返回null。
8. public E popFrist()
- 方法描述：弹出链表头部元素，并删除该节点。
- 实现过程: 1.如果链表长度为0,方法返回false。2.获取头部元素e,使用removeNode方法删除头结点head。3.返回e。
9. public E popLast()
- 方法描述：弹出链表尾部元素，并删除该节点。
- 实现过程: 1.如果链表长度为0,方法返回false。2.获取尾部元素e,使用removeNode方法删除尾结点last。3.返回e。
10. public Iterator iterator()：返回new LinkIterator(head, true)。
11. public Iterator reIterator()：返回new LinkIterator(last, false)。
其它为提到的方法，我们都可以沿用单向链表的实现思路来实现。
3.3 代码实现
01. import java.util.Collection;
02. import java.util.Iterator;
03.
04. public class DoubleLink<E> implements Collection<E>{
05.
06. private int size=0;
07. private Node<E> head=null;
08. private Node<E> last=null;
09. private final int MAX_SIZE;
10.
11. public DoubleLink() {
12. MAX_SIZE=2<<10;
13. }
14.
15. public DoubleLink(int linkSize) {
16. MAX_SIZE=linkSize>0?linkSize:2<<10;
17. }
18.
19. static class Node<E>{
20. E item;
21. Node<E> next;
22. Node<E> prev;
23.
24. public Node(E item,Node<E> prev,Node<E> next){
25. this.item=item;
26. this.prev=prev;
27. this.next=next;
28. }
29. }
30.
31. class LinkIterator implements Iterator<E>{
32.
33. private Node<E> start=null;
34. private boolean isNext=true;
35.
36. public LinkIterator(Node<E> startNode,boolean isNext) {
37. this.isNext=isNext;
38. start=this.isNext?new Node<>(null, null, startNode)
39. :new Node<>(null, startNode, null);
40. }
41.
42. @Override
43. public boolean hasNext() {
44. if(isNext) {
45. return start.next!=null;
46. }else {
47. return start.prev!=null;
48. }
49. }
50.
51. @Override
52. public E next() {
53. start=isNext?start.next:start.prev;
54. return start.item;
55. }
56.
57. }
58.
59. private void removeNode(Node<E> node) {
60. if(node==null) return;
61. //获取被删除节点的前后节点。
62. Node<E> prevNode=node.prev;
63. Node<E> nextNode=node.next;
64. //如果前节点不为空，更新前节点的next为后节点。
65. if(prevNode==null) {
66. head=head.next;
67. }else {
68. prevNode.next=nextNode;
69. }
70.
71. if(nextNode==null) {
72. last=last.prev;
73. }else {
74. nextNode.prev=prevNode;
75. }
76. //清空被删除节点的所有引用
77. node.next=null;
78. node.prev=null;
79. node.item=null;
80. size--;
81. }
82.
83.
84.
85. @Override
86. public int size() {
87. return this.size;
88. }
89.
90. @Override
91. public boolean isEmpty() {
92. return size==0?true:false;
93. }
94.
95. @Override
96. public boolean contains(Object o) {
97. if(o==null) return false;
98. Node<E> node=head;
99. while(node!=null) {
100. if(node.item.equals(o)) {
101. return true;
102. }
103. node=node.next;
104. }
105.
106. return false;
107. }
108.
109. @Override
110. public Iterator<E> iterator() {
111.
112. LinkIterator it=new LinkIterator(head, true);
113.
114. return it;
115. }
116.
117. public Iterator<E> reIterator() {
118. LinkIterator it=new LinkIterator(last, false);
119. return it;
120. }
121.
122. @Override
123. public boolean add(E e) {
124. if(e==null || size>=MAX_SIZE ) return false;
125. Node<E> node=new Node<E>(e, null, null);
126. if(size==0) {
127. head=last=node;
128. }else {
129. node.prev=last;
130. last.next=node;
131. last=node;
132. }
133. size++;
134. return true;
135. }
136.
137. @Override
138. public boolean remove(Object o) {
139.
140. if(o==null) return false;
141. boolean isRemove=false;
142. Node<E> node=head;
143. while(node!=null) {
144. if(node.item.equals(o)) {
145. Node<E> removeNode=node;
146. node=node.next;
147. removeNode(removeNode);
148. isRemove=true;
149. }else {
150. node=node.next;
151. }
152. }
153. return isRemove;
154. }
155.
156. @Override
157. public boolean containsAll(Collection<?> c) {
158. if(c==null) return false;
159.
160. Iterator<?> it=c.iterator();
161. while(it.hasNext()) {
162. Object e=it.next();
163. if(!contains(e)) {
164. return false;
165. }
166. }
167.
168. return true;
169. }
170.
171. @Override
172. public boolean addAll(Collection<? extends E> c) {
173. if(c==null) return false;
174. if(size>MAX_SIZE-c.size()) return false;
175. Iterator<? extends E> it=c.iterator();
176. while(it.hasNext()) {
177. if(!add(it.next())) {
178. return false;
179. }
180. }
181. return true;
182. }
183.
184. @Override
185. public boolean removeAll(Collection<?> c) {
186. if(c==null) return false;
187. Iterator<?> it=c.iterator();
188. while(it.hasNext()) {
189. Object collectEle=it.next();
190. if(contains(collectEle)) {
191. remove(collectEle);
192. }
193. }
194. return true;
195. }
196.
197. @Override
198. public boolean retainAll(Collection<?> c) {
199. if(c==null) return false;
200. Node<E> node=head;
201. while(node!=null) {
202. if(!c.contains(node.item)) {
203. remove(node.item);
204. }
205. node=node.next;
206. }
207.
208. return true;
209. }
210.
211. @Override
212. public void clear() {
213. while(head!=null) {
214. removeNode(head);
215. }
216. head=last=null;
217. size=0;
218. }
219.
220. @Override
221. public Object[] toArray() {
222. if(size==0) return null;
223. Object[] array=new Object[size];
224. Iterator<E> it=this.iterator();
225. for(int i=0;i<size;i++) {
226. array[i]=it.next();
227. }
228.
229. return array;
230. }
231.
232. @SuppressWarnings("unchecked")
233. @Override
234. public <T> T[] toArray(T[] a) {
235. T[] array=a;
236. Object[] src=this.toArray();
237. for(int i=0;i<array.length;i++) {
238. if(i<src.length) {
239. array[i]=(T) src[i];
240. }else {
241. array[i]=null;
242. }
243. }
244.
245. return array;
246. }
247.
248. public String toString() {
249. StringBuilder strs=new StringBuilder("");
250. Node<E> start=head;
251. while(start!=null) {
252. strs.append(start.item);
253. start=start.next;
254. strs.append(start!=null?",":"");
255. }
256.
257. return strs.toString();
258. }
259.
260. public E getHead() {
261. return head==null?null:head.item;
262. }
263.
264. public E getLast() {
265. return last==null?null:last.item;
266. }
267.
268. public E pushFrist(E e) {
269.
270. if(e==null) return null;
271.
272. if(size==0) return pushLast(e);
273.
274. Node<E> node=new Node<>(e,null,head);
275. head.prev=node;
276. head=node;
277. size++;
278.
279. return e;
280. }
281.
282. public E pushLast(E e) {
283. if(e==null) return null;
284.
285. return add(e)?e:null;
286. }
287.
288. public E popFrist() {
289. if(size==0) return null;
290.
291. E e=head.item;
292. removeNode(head);
293.
294. return e;
295. }
296.
297. public E popLast() {
298.
299. if(size==0) return null;
300. E e=last.item;
301. removeNode(last);
302.
303. return e;
304. }
305. }
4 链表的测试用例
两个测试用的数据初始方法和数据输出方法分别如下所示：
方法1 初始化链表数据，并返回链表。
01. public static DoubleLink<Integer> createLink(int size){
02. DoubleLink<Integer> link=new DoubleLink<>();
03. for(int i=0;i<size;i++) {
04. link.add(i);
05. }
06.
07. return link;
08. }
方法2 输出链表重要信息，并输出链表内容
01. public static void showLink(Link<?> link) {
02. System.out.println("head="+link.getHead()
03. +",last="+link.getLast()
04. +",size="+link.size());
05. System.out.println("link="+link);
06. }
1. iterator和reIterator方法测试用例内容：测试正向迭代和反向迭代是否正常使用。
01. public static void iteratorTest() {
02. DoubleLink<Integer> dl=createLink(15);
03. Iterator<Integer> it=dl.iterator();
04. while(it.hasNext()) {
05. System.out.print(it.next()+" ");
06. }
07. System.out.println();
08. Iterator<Integer> it2=dl.reIterator();
09. while(it2.hasNext()) {
10. System.out.print(it2.next()+" ");
11. }
用例运行结果：
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14
14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
2.remove方法测试用例内容：删除头结点、尾节点，中间节点，观察删除前后的链表变化。
01. public static void removeTest() {
02. DoubleLink<Integer> dl=createLink(15);
03. dl.add(14);
04. dl.add(15);
05. showLink(dl);
06. System.out.println("remove 15:"+dl.remove(new Integer(15)));
07. showLink(dl);
08. System.out.println("remove 0:"+dl.remove(new Integer(0)));
09. showLink(dl);
10. System.out.println("remove 14:"+dl.remove(new Integer(14)));
11. showLink(dl);
12. }
用例运行结果：
head=0,last=15,size=17
link=0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,14,15
remove 15:true
head=0,last=14,size=16
link=0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,14
remove 0:true
head=1,last=14,size=15
link=1,2,3,4,5,6,7,8,9,10,11,12,13,14,14
remove 14:true
head=1,last=13,size=13
link=1,2,3,4,5,6,7,8,9,10,11,12,13
3. pushFrist和pushLast方法测试用例内容：在空链表基础上用push方式添加数据，每种添加方式各添加10个，最后观察链表的变化。
01. public static void pushTest() {
02. DoubleLink<Integer> dl=new DoubleLink<>(100);
03. for(int i=0;i<20;i++) {
04. if(i<10) {
05. dl.pushFrist(i);
06. }else {
07. dl.pushLast(i);
08. }
09. }
10. showLink(dl);
11. }
用例运行结果：
head=9,last=19,size=20
link=9,8,7,6,5,4,3,2,1,0,10,11,12,13,14,15,16,17,18,19
4. popFrist和popLast方法测试用例内容：从有数据的链表中用pop方式获取数据，并观察链表的变化。
01. public static void popTest() {
02. DoubleLink<Integer> dl=createLink(15);
03. showLink(dl);
04. System.out.println("head pop="+dl.popFrist());
05. showLink(dl);
06. System.out.println("last pop="+dl.popLast());
07. showLink(dl);
08. }
用例运行结果：
head=0,last=14,size=15
link=0,1,2,3,4,5,6,7,8,9,10,11,12,13,14
head pop=0
head=1,last=14,size=14
link=1,2,3,4,5,6,7,8,9,10,11,12,13,14
last pop=14
head=1,last=13,size=13
link=1,2,3,4,5,6,7,8,9,10,11,12,13
5. clear方法测试用例内容：观察链表清空前后的信息变化。
01. public static void clearTest() {
02. DoubleLink<Integer> dl=createLink(15);
03. showLink(dl);
04. dl.clear();
05. showLink(dl);
06. }
用例运行结果：
head=0,last=14,size=15
link=0,1,2,3,4,5,6,7,8,9,10,11,12,13,14
head=null,last=null,size=0
link=
5 总结
双向链表是使用比较多的一种数据结构，我们可以参考Collection集合体系下的LinkedList类的实现，它是一个比较好的链表实现，如果我们要对链表的性能和功能有所提升，参考它的源码时非常有意义的。
我们设计的链表并不是一个线程安全的链表，在多线程的情况下，它依然会出现各种各样的问题，有兴趣的话可以为链表加上同步功能。关于链表的设计和实现我们就告一段落。