算法（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;
}