算法（10） 链表

        这篇的代码不是自己写的是参考来的，虽然原博主代码写得不是很规范，但是基本思路是正确的，可作为学习的材料。原博地址 http://blog.csdn.net/cyp331203/article/details/42388065

———————————————————————————————————————————————————

        不带哨兵节点的双向链表即一般的双向链表，有一个头指针指向第一个节点，每个节点有key值和两个指针next和pre，分别指向前后相邻的节点，头结点的pre=NULL，尾节点的next=NULL，比较明了，但是也有麻烦的地方：在做查找删除节点等操作的时候，免不了要判断边界条件，比如node==NULL等。先来看看这种链表的代码：

[cpp] view plain copy

print?

1. /* 
2.  * 实现没有哨兵节点的双向链表，需要自己判断边界条件 
3.  */  
4. #include <iostream>  
5.   
6. using namespace std;  
7.   
8. class list {  
9.     struct node {  
10.         int key;  
11.         node* next;  
12.         node* pre;  
13.         node(int k) :  
14.                 key(k), next(NULL), pre(NULL) {  
15.         }  
16.     };  
17.   
18. public:  
19.     node* head;  
20.     int len;  
21.   
22.     list() :  
23.             head(NULL), len(0) {  
24.     }  
25.   
26.     ~list() {  
27.         node* tmp1 = head, *tmp2;  
28.   
29.         while (tmp1 != NULL) {  
30.             tmp2 = tmp1->next;  
31.             delete tmp1;  
32.             len--;  
33.             cout << "len=" << len << endl;  
34.             tmp1 = tmp2;  
35.         }  
36.     }  
37.   
38.     /* 
39.      * 在头处插入节点 
40.      */  
41.     void insertHead(int k) {  
42.         node* n = new node(k);  
43.         n->next = head;  
44.         head = n;  
45.         if (n->next != NULL) {  
46.             n->next->pre = n;  
47.         }  
48.         len++;  
49.     }  
50.   
51.     /* 
52.      * 删除指针指向的节点 
53.      */  
54.     int del(node* n) {  
55.         if (n == NULL) {  
56.             return -1;  
57.         }  
58.         if (n->pre != NULL) {  
59.             n->pre->next = n->next;  
60.         } else {  
61.             head = n->next;  
62.         }  
63.         if (n->next != NULL) {  
64.             n->next->pre = n->pre;  
65.         }  
66.   
67.         delete n;  
68.         len--;  
69.         return n->key;  
70.     }  
71.   
72.     /* 
73.      * 查找具有某个key值的节点 
74.      */  
75.     node* searchList(int k) {  
76.         if (len == 0) {  
77.             return NULL;  
78.         }  
79.         node* tmp = head;  
80.         while (tmp != NULL) {  
81.             if (tmp->key == k) {  
82.                 break;  
83.             }  
84.             tmp = tmp->next;  
85.         }  
86.         return tmp;  
87.     }  
88.   
89.     /* 
90.      * 遍历list 
91.      */  
92.     void travelList() {  
93.         node* tmp = head;  
94.         while (tmp != NULL) {  
95.             cout << tmp->key << ' ';  
96.             tmp = tmp->next;  
97.         }  
98.         cout << endl;  
99.     }  
100.   
101. };  
102.   
103. int main() {  
104.   
105.     list* l = new list();  
106.     l->insertHead(5);  
107.     l->insertHead(4);  
108.     l->insertHead(3);  
109.     l->travelList();  
110.     l->del(l->head->next);  
111.     l->travelList();  
112.   
113.     delete l;  
114.   
115.     return 0;  
116. }  

/* * 实现没有哨兵节点的双向链表，需要自己判断边界条件 */#include <iostream>using namespace std;class list {struct node {int key;node* next;node* pre;node(int k) :key(k), next(NULL), pre(NULL) {}};public:node* head;int len;list() :head(NULL), len(0) {}~list() {node* tmp1 = head, *tmp2;while (tmp1 != NULL) {tmp2 = tmp1->next;delete tmp1;len--;cout << "len=" << len << endl;tmp1 = tmp2;}}/* * 在头处插入节点 */void insertHead(int k) {node* n = new node(k);n->next = head;head = n;if (n->next != NULL) {n->next->pre = n;}len++;}/* * 删除指针指向的节点 */int del(node* n) {if (n == NULL) {return -1;}if (n->pre != NULL) {n->pre->next = n->next;} else {head = n->next;}if (n->next != NULL) {n->next->pre = n->pre;}delete n;len--;return n->key;}/* * 查找具有某个key值的节点 */node* searchList(int k) {if (len == 0) {return NULL;}node* tmp = head;while (tmp != NULL) {if (tmp->key == k) {break;}tmp = tmp->next;}return tmp;}/* * 遍历list */void travelList() {node* tmp = head;while (tmp != NULL) {cout << tmp->key << ' ';tmp = tmp->next;}cout << endl;}};int main() {list* l = new list();l->insertHead(5);l->insertHead(4);l->insertHead(3);l->travelList();l->del(l->head->next);l->travelList();delete l;return 0;}

        每次判断边界条件，虽然不会从根本上增加时间复杂度，但是对其常数项还是有影响的；而如果使用带哨兵节点构成的双向循环链表，则可以省去这些问题。我们使用一个“哑的”NIL节点来代替之前的head头指针，NIL节点的key值没有实际的意义，主要关注它的next和pre，初始的时候，链表只有一个NIL节点，NIL.next指向自己，NIL.pre也指向自己。当添加了若干个节点之后，NIL.next指向头节点，而NIL.pre则指向尾节点；而同样的，这时头节点的pre不再是NULL而是指向NIL，尾节点的next也不再是NULL，也是指向NIL。

        这样的好处在于，我们判断边界条件的时候，不需要再判断是否为空，尤其在删除节点的时候，只需要写两句即可。但是这样也带来一些问题，就是要额外分配空间来存储NIL节点，如果对于多个比较短的链表而言，这样可能会代码比较大的冗余空间。

代码如下：

[cpp] view plain copy

print?

1. /* 
2.  * 实现带哨兵是双向循环链表 
3.  */  
4. #include <iostream>  
5.   
6. using namespace std;  
7.   
8. class list {  
9.     struct node {  
10.         int key;  
11.         node* next;  
12.         node* pre;  
13.         node(int k) :  
14.                 key(k), next(NULL), pre(NULL) {  
15.         }  
16.     };  
17.   
18. //  node* head;  
19. public:  
20.     node* nil; //哨兵节点  
21.     int len;  
22.     list() :  
23.             nil(), len(0) {  
24.         nil = new node(0); //初始化哨兵节点  
25.         //让链表循环起来  
26.         nil->next = nil;  
27.         nil->pre = nil;  
28.     }  
29.   
30.     ~list() {  
31.         //析构的时候要delete掉还存在于list中的节点  
32.         if (len == 0) {  
33.             delete nil;  
34.             return;  
35.         }  
36.         node* n1 = nil->next;  
37.         node* n2 = NULL;  
38.         while (n1 != NULL && n1 != nil) {  
39.             n2 = n1->next;  
40.             delete n1;  
41.             len--;  
42.             n1 = n2;  
43.         }  
44.         delete nil;  
45.     }  
46.   
47.     /* 
48.      * 在头部插入节点 
49.      */  
50.     void insertHead(int k) {  
51.         node* n = new node(k);  
52.         n->next = nil->next;  
53.         n->pre = nil;  
54.   
55.         nil->next = n;  
56.   
57.         //这一句不要丢了  
58.         n->next->pre = n;  
59.         len++;  
60.     }  
61.   
62.     /* 
63.      * 删除节点，这里删除的操作只需要写两句，比不带哨兵的链表操作要简洁的多 
64.      */  
65.     void del(node* n) {  
66.         n->pre->next = n->next;  
67.         n->next->pre = n->pre;  
68.         delete n;  
69.         len--;  
70.     }  
71.   
72.     node* searchList(int k) {  
73.         node* tmp = nil->next;  
74.   
75.         //让nil的key值永远不可能等于k  
76. //      nil->key = k + 1;  
77.   
78. //      while (tmp->key != k) {  
79.         while (tmp != nil && tmp->key != k) {  
80.             tmp = tmp->next;  
81.         }  
82.         if (tmp != nil) {  
83.             return tmp;  
84.         } else {  
85.             return NULL;  
86.         }  
87.     }  
88.   
89.     /* 
90.      * 从next指针方向遍历链表 
91.      */  
92.     void travelClockwise() {  
93.         node* tmp = nil->next;  
94.         while (tmp != nil) {  
95.             cout << tmp->key << ' ';  
96.             tmp = tmp->next;  
97.         }  
98.         cout << endl;  
99.     }  
100.   
101.     /* 
102.      * 从pre指针方向遍历链表 
103.      */  
104.     void travelAnticlockwise() {  
105.         node* tmp = nil->pre;  
106.         while (tmp != nil) {  
107.             cout << tmp->key << ' ';  
108.             tmp = tmp->pre;  
109.         }  
110.         cout << endl;  
111.   
112.     }  
113.   
114. };  
115.   
116. int main() {  
117.   
118.     list* l = new list();  
119.     l->insertHead(5);  
120.     l->insertHead(4);  
121.     l->insertHead(3);  
122.     l->travelClockwise();  
123.     l->del(l->nil->pre);  
124. //  l->travelClockwise();  
125.     l->travelAnticlockwise();  
126.     return 0;  
127. }  

/* * 实现带哨兵是双向循环链表 */#include <iostream>using namespace std;class list {struct node {int key;node* next;node* pre;node(int k) :key(k), next(NULL), pre(NULL) {}};//node* head;public:node* nil; //哨兵节点int len;list() :nil(), len(0) {nil = new node(0); //初始化哨兵节点//让链表循环起来nil->next = nil;nil->pre = nil;}~list() {//析构的时候要delete掉还存在于list中的节点if (len == 0) {delete nil;return;}node* n1 = nil->next;node* n2 = NULL;while (n1 != NULL && n1 != nil) {n2 = n1->next;delete n1;len--;n1 = n2;}delete nil;}/* * 在头部插入节点 */void insertHead(int k) {node* n = new node(k);n->next = nil->next;n->pre = nil;nil->next = n;//这一句不要丢了n->next->pre = n;len++;}/* * 删除节点，这里删除的操作只需要写两句，比不带哨兵的链表操作要简洁的多 */void del(node* n) {n->pre->next = n->next;n->next->pre = n->pre;delete n;len--;}node* searchList(int k) {node* tmp = nil->next;//让nil的key值永远不可能等于k//nil->key = k + 1;//while (tmp->key != k) {while (tmp != nil && tmp->key != k) {tmp = tmp->next;}if (tmp != nil) {return tmp;} else {return NULL;}}/* * 从next指针方向遍历链表 */void travelClockwise() {node* tmp = nil->next;while (tmp != nil) {cout << tmp->key << ' ';tmp = tmp->next;}cout << endl;}/* * 从pre指针方向遍历链表 */void travelAnticlockwise() {node* tmp = nil->pre;while (tmp != nil) {cout << tmp->key << ' ';tmp = tmp->pre;}cout << endl;}};int main() {list* l = new list();l->insertHead(5);l->insertHead(4);l->insertHead(3);l->travelClockwise();l->del(l->nil->pre);//l->travelClockwise();l->travelAnticlockwise();return 0;}