Java实现单链表和双链表

首先给出一个链表模型：

第一步：  创建空链表   

第二步：创建头节点

第三部：创建尾节点

到此为止 一个比较有完整意义的链表已经构造出 

增加节点

删除节点：

参考代码：

[java] view plain copy

1. package org.hunan.guan.javaIO;  
2.   
3. public class LinkList<T> {  
4.   
5.     private Node<T> tail; //尾节点  
6.     private Node<T> head; //头节点  
7.   
8.     public LinkList() {  
9.         head = tail = null;  
10.     }  
11.   
12.     public static class Node<T> {  
13.         T data;  
14.         Node<T> next;  
15.   
16.         Node(T data, Node<T> next) {  // 当为中间节点的时候用此构造方法  
17.             this.data = data;  
18.             this.next = next;  
19.         }  
20.   
21.         Node(T data) {                  // 当为头结点或尾节点的时候 使用此构造方法  
22.             this.data = data;  
23.             this.next = null;  
24.         }  
25.     }  
26.   
27.     public void addHead(T point) {      // 为空链表增加头结点  
28.         head = new Node<T>(point);  
29.         if (tail == null) {  
30.             tail = head;  
31.         }  
32.     }  
33.   
34.     public void addTail(T point) {      // 为链表增加尾节点  
35.         tail = new Node<T>(point);  
36.         head.next = tail;  
37.     }  
38.   
39.     public boolean insert(T point) {  
40.         Node<T> preNext = head.next;  
41.         Node<T> newNode = new Node<T>(point, preNext);  
42.         if (head.next != null) {  
43.             preNext = head.next;  
44.             head.next = newNode;  
45.             newNode.next = preNext;  
46.   
47.         }  
48.         return true;  
49.     }  
50.   
51.     public void show() { // 打印链表  
52.         Node<T> curr = head;  
53.         if (isEmpty()) {  
54.             System.out.print(head.data + " ");  
55.             curr = head.next;  
56.         } else {  
57.             System.out.println("链表错误");  
58.             return;  
59.         }  
60.   
61.         while (curr != null) {  
62.             System.out.print(curr.data + " ");  
63.             curr = curr.next;  
64.         }  
65.     }  
66.   
67.     public void delete(T data) { // 删除某一节点  
68.         Node<T> curr = head, prev = null;  //curr为当前节点，prev为最后一个节点  
69.         boolean b = false;  
70.         while (curr != null) {  
71.   
72.             if (curr.data.equals(data)) {  
73.                 // 判断是什么节点  
74.                 if (curr == head) { // 如果删除的是头节点  
75.                     System.out.println('\n' + "delete head node");  
76.                     head = curr.next;  
77.                     b = true;  
78.                     return;  
79.                 }  
80.                 if (curr == tail) { // 如果删除的是尾节点  
81.                     System.out.println('\n' + "delete tail node");  
82.   
83.                     tail = prev;  
84.                     prev.next = null;  
85.   
86.                     b = true;  
87.                     return;  
88.                 } else { // 如果删除的是中间节点（即非头节点或非尾节点）  
89.                     System.out.println('\n' + "delete center node");  
90.                     prev.next = curr.next;  
91.                     b = true;  
92.                     return;  
93.                 }  
94.   
95.             }  
96.   
97.             prev = curr;  
98.             curr = curr.next;  
99.         }  
100.         if (b == false) {  
101.             System.out.println('\n' + "没有这个数据");  
102.         }  
103.   
104.     }  
105.   
106.     public boolean isEmpty() { // 判断链表是否为空  
107.         if (head != null && tail != null) {  
108.             return true;  
109.         }  
110.         return false;  
111.     }  
112.   
113.     public static void main(String[] args) {  
114.         // TODO Auto-generated method stub  
115.         LinkList<Integer> mylist = new LinkList<Integer>();// 构造一个空链表  
116.         mylist.addHead(5);  
117.         mylist.addTail(6);  
118.         mylist.insert(7);  
119.         mylist.insert(3);  
120.         mylist.show();  
121.         mylist.delete(1);  
122.         mylist.show();  
123.         mylist.delete(5);  
124.         mylist.show();  
125.         mylist.delete(6);  
126.         mylist.show();  
127.     }  
128.   
129. }  

运行结果：

5 3 7 6 
没有这个数据
5 3 7 6 
delete head node
3 7 6 
delete tail node
3 7 

参考网址：http://blog.csdn.net/liushengbaoblog/article/details/10823039

双向链表实现：（网上摘录）

[java] view plain copy

1. package org.hunan.guan.javaIO;  
2.   
3. public class DoubleLinkedList{  
4.     // 节点类Node  
5.     private static class Node {  
6.         Object value;  
7.         Node prev = this;  
8.         Node next = this;  
9.   
10.         Node(Object v) {  
11.             value = v;  
12.         }  
13.   
14.         public String toString() {  
15.             return value.toString();  
16.         }  
17.     }  
18.   
19.     private Node head = new Node(null); // 头节点  
20.     private int size; // 链表大小  
21.   
22.     // 以下是接口方法  
23.     public boolean addFirst(Object o) {  
24.         addAfter(new Node(o), head);  
25.         return true;  
26.     }  
27.   
28.     public boolean addLast(Object o) {  
29.         addBefore(new Node(o), head);  
30.         return true;  
31.     }  
32.   
33.     public boolean add(Object o) {  
34.         return addLast(o);  
35.     }  
36.   
37.     public boolean add(int index, Object o) {  
38.         addBefore(new Node(o), getNode(index));  
39.         return true;  
40.     }  
41.   
42.     public boolean remove(int index) {  
43.         removeNode(getNode(index));  
44.         return true;  
45.     }  
46.   
47.     public boolean removeFirst() {  
48.         removeNode(head.next);  
49.         return true;  
50.     }  
51.   
52.     public boolean removeLast() {  
53.         removeNode(head.prev);  
54.         return true;  
55.     }  
56.   
57.     public Object get(int index) {  
58.         return getNode(index).value;  
59.     }  
60.   
61.     public int size() {  
62.         return size;  
63.     }  
64.   
65.     public String toString() {  
66.         StringBuffer s = new StringBuffer("[");  
67.         Node node = head;  
68.         for (int i = 0; i < size; i++) {  
69.             node = node.next;  
70.             if (i > 0)  
71.                 s.append(", ");  
72.             s.append(node.value);  
73.         }  
74.         s.append("]");  
75.         return s.toString();  
76.     }  
77.   
78.     // 以下是实现方法  
79.     private Node getNode(int index) {  
80.         if (index < 0 || index >= size)  
81.             throw new IndexOutOfBoundsException();  
82.         Node node = head.next;  
83.         for (int i = 0; i < index; i++)  
84.             node = node.next;  
85.         return node;  
86.     }  
87.   
88.     private void addBefore(Node newNode, Node node) {  
89.         newNode.next = node;  
90.         newNode.prev = node.prev;  
91.         newNode.next.prev = newNode;  
92.         newNode.prev.next = newNode;  
93.         size++;  
94.     }  
95.   
96.     private void addAfter(Node newNode, Node node) {  
97.         newNode.prev = node;  
98.         newNode.next = node.next;  
99.         newNode.next.prev = newNode;  
100.         newNode.prev.next = newNode;  
101.         size++;  
102.     }  
103.   
104.     private void removeNode(Node node) {  
105.         node.prev.next = node.next;  
106.         node.next.prev = node.prev;  
107.         node.prev = null;  
108.         node.next = null;  
109.         size--;  
110.     }  
111.   
112.     // 有些地方还可以优化，比如查找时可以判断索引是否大于size的一半，如果是的话，就从另一头开始迭代。  
113.     // 可以用这个类测试一下：  
114.   
115.     public static void main(String[] args) {  
116.         DoubleLinkedList dll = new DoubleLinkedList();  
117.         // 添加  
118.         dll.add("张曼玉");  
119.         dll.add("钟楚红");  
120.         dll.add("刘嘉玲");  
121.         System.out.println(dll);  
122.         // 添加到最前  
123.         dll.addFirst("林青霞");  
124.         System.out.println(dll);  
125.         // 添加到最后，同添加  
126.         dll.addLast("梅艳芳");  
127.         System.out.println(dll);  
128.         // 添加到指定位置  
129.         dll.add(4, "王祖贤");  
130.         System.out.println(dll);  
131.         // 移除最前的  
132.         dll.removeFirst();  
133.         System.out.println(dll);  
134.         // 移除最后的  
135.         dll.removeLast();  
136.         System.out.println(dll);  
137.         // 移除指定位置上的  
138.         dll.remove(2);  
139.         System.out.println(dll);  
140.         // 返回指定位置上的元素  
141.         System.out.println(dll.get(1));  
142.     }  
143. }  

运行结果：

[张曼玉, 钟楚红, 刘嘉玲]
[林青霞, 张曼玉, 钟楚红, 刘嘉玲]
[林青霞, 张曼玉, 钟楚红, 刘嘉玲, 梅艳芳]
[林青霞, 张曼玉, 钟楚红, 刘嘉玲, 王祖贤, 梅艳芳]
[张曼玉, 钟楚红, 刘嘉玲, 王祖贤, 梅艳芳]
[张曼玉, 钟楚红, 刘嘉玲, 王祖贤]
[张曼玉, 钟楚红, 王祖贤]
钟楚红

参考网址：http://www.java3z.com/cwbwebhome/article/article8/83538.html?id=4605

这里我主要分四个知识点来介绍链表，分别是单向链表、单向循环链表、双向链表和双向循环链表。操作包括链表的初始化、链表的创建、链表插入结点、链表删除结点以及链表的删除，也就是释放内存。

源代码链接：

• （C++版）单向链表
  
• （C++版）单向循环链表
  
• （C++版）双向链表
  
• （C++版）双向循环链表
  

单向链表

1. 单向链表就是通过每个结点的指针指向下一个结点从而链接起来的结构。下面看下单向链表的示意图（以下图片全是原创）
2. 单向链表的初始化：这里我所讲的链表都是头结点不参与计算的，也就是说第一个结点都是头结点后面的第一个结点。所以我要先申明一点，这里我把链表的初始化放在了构造函数部分，然后析构函数负责释放头结点的内存。
3. 单向链表的创建过程：链表的创建就是添加结点到链表的最后，开始是添加一个结点到head结点后面，然后添加一个结点到上次添加的结点后面，每次新建的结点的指针总是指向NULL指针。从上面的示意图可以看出，我们需要一个辅助指针一直指向最后一个结点，这个辅助结点就是为了让每次添加的结点都放置在最后一个位置。
4. 单向链表插入结点过程：源代码中的的插入结点函数我设置了一个指定位置，就是在指定位置插入结点。首先，通过位置变量position让ptemp结点移动到要插入位置的前一个位置，然后接下来的过程就是和创建链表的过程是一样的，把新建的结点添加到ptemp的后面。这里变量position可以从1到链表长度加1，意思就是如果不算头结点的话有3个结点，那你的position变量就可以从1到4，这是因为ptemp指针可以到第3个结点的位置，所以新建结点的位置就可以到4了。
5. 单向链表删除结点过程：源代码中的删除结点函数也有一个指定位置变量，为了删除指定位置的结点。和插入结点一样通过变量position把ptemp移动到要删除结点的前一个位置，然后让ptemp结点中的指针指向要删除结点后面的一个结点，也就是ptemp结点的下一个的下一个结点，虽然这个结点可能为空，但是程序还是正常运行。但是这里和插入结点不同的是变量position只能从1到链表的长度，是因为ptemp移动到最后一个结点的时候，它的下一个结点为空，所以不不需要参与删除了。

单向循环链表

1.单向循环链和单向链表有点相似的地方，就是都是通过结点的指针指向下一个结点，然后这样连接起来，但是有一个不同的地方就是单向链表的最后一个结点的指针指向NULL指针，而单向循环链表的最后一个结点的指针指向的是头结点，这样构成一个循环结点的环。下面是单向循环链表的示意图：

2.单向循环链表的初始化：从上面的示意图可以知道，单向循环链表最后一个结点的指针是指向头结点的，那么当只有一个结点的时候就是头结点的指针指自己。

3.单向循环链表的创建过程：和单向链表的创建过程相似，区别就是最后一个结点的指针是指着头结点的。所以程序实现的时候每次新建一个结点的时候都是让它的指针指向头结点。

4.单向循环链表插入结点过程：因为这个时候是往链表中插入结点，结点已经构成一个环了，所以直接让新插入结点的指针指向下一个结点就行。就算插入的是最后一个位置，让它的指针指向下一个结点也符合条件，因为最后一个位置的下一个结点就是头结点。

5.单向循环链表删除结点过程：结合单向链表删除结点过程和上面单向循环链表插入结点过程的解释，那么这里就不难理解了。

双向链表

1.听名字可能就能猜到双向链表就是链表结点包含两个指针，一个指针是指向下一个结点的，另一个指针当然就是指向上一个结点的。这样的链表就可以通过第一个结点找到最后一个结点，当然也可以通过最后一个结点找到第一个结点，因为它是双向的，下面看下双向链表的示意图：

2.双向链表的初始化：由于这里的链表头结点不参与计算，所以头结点的pPre指针是一直指向NULL指针的。

3.双向链表的创建过程：由于双向链表的每个结点包含两个指针那么这个时候我们就要小心处理好每一个指针的指向，要不然会有很多意想不到的错误。同样的，和单向链表的创建过程一样，需要一个辅助指针来指向最后一个结点，然后每新建一个结点，这个结点的pNext指针都是指向NULL指针的，pPre指针指向上一个结点（这是和单向链表不同的地方），然后让上一个指针的pNext指向新建的结点，这样整个链表就连接起来了。

4.双向链表插入结点过程：知道了双向链表的创建过程，那么插入结点的过程就大同小异 了，有一点需要特别注意的就是这里的变量position范围也是从1到链表长度加1，但是如果待插入的位置是最后一个位置的话，情况就不同了，看到下面的图我们可以很好的理解，因为没新建一个结点的时候都需要处理两个指针，而且新建结点的下一个结点的pPre指针就需要指向这个新建的结点，但是有可能这个新建的结点可能就已经是最后一个结点了，那么这个时候再执行

[cpp] view plaincopy

1. ptemp->pNext->pPre = pnew;  

这条指令的时候就会报错了，因为ptemp->pNext已经是个NULL指针了，那空指针哪里还有pPre呢。因此在程序中要进行一次判断，看看结点是否是最后一个结点。

5.双向链表删除结点的过程：要注意的问题和插入结点一样，看看这个结点是否为NULL。这里就不重复了。

双向循环链表

1.双向循环链表相对于上面的双向链表多了循环两个字，我们就可以结合单向循环链表联想到，其实就是双向链表够成了一个环。下面先看看双向循环链表的示意图：

2.双向循环链表初始化：双向循环链表的初始化可以通过单向循环链表的初始化联想到，就是两个指针都指向头结点本身。这是因为pPre指针要指向上一个结点，而pNext指针要指向下一个结点，这个时候就只有头结点一个，所以就都指向头结点了。

3.双向循环链表的创建过程：这个也过程和上面单向循环链表都类似，就是多了一个结点指针要考虑到。

4.双向循环链表插入结点过程：和单向循环链表过程类似。

5.双向循环链表删除结点过程：这个也是和单向循环链表类似。

        写了2个多小时，终于快结束了，其实加上画图和敲源代码总共花了好几天的时间。最后我想说说我对链表的一点个人理解，开始学习的时候看过去挺简单的，但是自己操作的时候就会发现遇到很多细节性的问题，所以劝解那些看的人还是动动手自己写一遍。然后呢，我想说的是，这里列出的只是链表的一些简单操作，不能说会了这些链表就都会了，当然知识也是相通的，如果真正理解了的话，那不管怎么变也不怕了。比如：链表数据的排序、然后输入结点时按顺序插入等，还有很多很多。

参考网址：http://blog.csdn.net/fisherwan/article/details/25796625