双链表

单链表是最基本最简单的结构了，用处也蛮多的吧，尤其是后面在层序结构的各种树与图结构的时候大量使用链表而且还很多是单链表形式的。学习双向链表还是由约瑟夫问题引入的呢，在单链表的删除操作时需要用并排的两个指针同步向后移动，为避免这个问题双向链表就派上用场了。双向链表顾名思义是每个结点有两个方向了，那么在结点里面不仅仅要保存一个后向指针还要保存一个前向指针了。

[cpp] view plain copy print ?

1. #pragma once
2. #include<iostream>
3. using namespace std;
4. template<class T>
5. class LinkNode //节点类
6. {
7. public: //全为公共的方便操作
8. T data; //模板类型的一个数据
9. LinkNode<T> *next; //该结点的一个指针，用于指向后继
10. LinkNode<T> *prior;//用于指向前驱
11. public:
12. LinkNode(LinkNode<T> *ptr = NULL)//只初始化指针的构造函数,并使指针域为空
13. { next = ptr; prior = ptr; }
15. LinkNode(const T& item,LinkNode<T> *ptr = NULL)//数据与指针一同初始化的构造函数，依旧指针域默认参数为空
16. { data = item; next = ptr; prior = ptr; }
18. ~LinkNode(){}
19. };

#pragma once
#include<iostream>
using namespace std;
template<class T>
class LinkNode //节点类
{
public:           //全为公共的方便操作
	T data; //模板类型的一个数据
	LinkNode<T> *next; //该结点的一个指针，用于指向后继
	LinkNode<T> *prior;//用于指向前驱
public:
	LinkNode(LinkNode<T> *ptr = NULL)//只初始化指针的构造函数,并使指针域为空
	{ next = ptr; prior = ptr; }

	LinkNode(const T& item,LinkNode<T> *ptr = NULL)//数据与指针一同初始化的构造函数，依旧指针域默认参数为空
	{ data = item; next = ptr; prior = ptr; }

	~LinkNode(){}
};

双向链表在插入的时候搭链是一个很有讲究的过程，某些步骤是有严格顺序的：

[cpp] view plain copy print ?

1. newNode->prior = current; //双向链表插入的关键四步，最后一句必须最后执行
2. newNode->next = current->next;
3. current->next->prior = newNode;
4. current->next = newNode;

	newNode->prior = current; //双向链表插入的关键四步，最后一句必须最后执行
	newNode->next = current->next;
	current->next->prior = newNode;
	current->next = newNode;

大致上就是先搞定新结点的prior和next指针，然后是待插位置的后一个结点的prior和前一个结点的next了。

双向链表的删除直接是先保存待删除结点指针然后覆盖就行了，其他的操作基本可以看作是单链表了。

[cpp] view plain copy print ?

1. #pragma once
2. //#include"LinearList.h"
3. #include"LinkNode.h"
4. #include<iostream>
5. using namespace std;
6. template<class T>//继承的过程中，加上此句派生类依然为类模板
7. class List
8. {
9. protected:
10. LinkNode<T>* first;//封装
11. public:
12. List();
13. //List(const T& x);//感觉没用到过
14. List(List<T>& L);
15. ~List();
16. void makeEmpty();//依次销毁每个结点的空间
18. int Length() const;//搜索当前表节点数
19. LinkNode<T>* getHead() const;//返回头指针
20. LinkNode<T>* Search(T x) const;//搜索并返回指针
21. LinkNode<T>* Locate(int i)const;//定位并返回指针
23. bool GetData(int i,T& x)const;//返回第i个结点的元素值以引用的形式
24. bool SetData(int i,T& x);//修改第i个结点的元素值
25. bool Insert(int i,T& x);//在第i个节点后面插入新节点元素值
26. LinkNode<T>* Remove(int i,T& x);//删除第i个结点
28. bool isEmpty() const;//判表空
30. void Sort(); //排序
31. void input(T endTag);//建立表并输入
32. void output();//输出表
33. void operator = (List<T>& L);//复制重载
34. };
36. template<class T>
37. List<T>::List()
38. {
39. first = new LinkNode<T>;//构造函数中开辟头结点
40. }
42. template<class T>
43. List<T>::List(List<T>& L)
44. {
45. LinkNode<T> *srcptr = L.getHead() ->next; //获取头指针 用于遍历
46. LinkNode<T> *destptr = first = new LinkNode<T>;//建立头结点 初始化
47. LinkNode<T> *newNode;
48. T value;
49. while(srcptr != NULL)//直到最后一个结点的尾指针为空结束
50. {
51. value = srcptr->data;
52. newNode = new LinkNode<T>(value);
54. newNode->prior = destptr;//往新链表的后面插入
55. destptr->next = newNode;
57. srcptr = srcptr->next;//后移
58. destptr = destptr->next;
59. }
60. }
61. template<class T>
62. List<T>::~List()
63. {}
65. template<class T>
66. void List<T>::makeEmpty() //全部销毁指针资源
67. {
68. LinkNode<T> *current = first->next;
69. LinkNode<T> *del;
70. while(current != NULL)
71. {
72. del = current;
73. current = current->next;
74. delete del;
75. }
76. }
78. template<class T>
79. int List<T>::Length() const
80. {
81. int count = 0;
82. LinkNode<T> *current = first;//头指针副本用于遍历
83. while(current->next != NULL)//与单链表的遍历控制条件相同，当前结点后后继是否为空
84. {
85. current = current->next;
86. count++ ;
87. }
88. return count;
89. }
91. template<class T>
92. LinkNode<T>* List<T>::getHead() const
93. {
94. return first;
95. }
96. template<class T>
97. LinkNode<T>* List<T>::Search(T x) const
98. {
99. LinkNode<T> *current = first->next;
100. while(current != NULL)//此时的控制条件为某个结点的next知否为空
101. {
102. if(current->data == x)
103. return current;//如果查询到直接函数返回,不用无用操作(如果链表中有多个x元素值,则以第一个为准返回)
104. current = current->next;
105. }
106. return NULL;
107. }
108. template<class T>
109. LinkNode<T>* List<T>::Locate(int i)const
110. {
111. if(i < 0) //定位可以是第0个，也就是头结点指针
112. return NULL;
113. LinkNode<T> *current = first;int k=0;
114. while(current != NULL && k < i)//双条件控制后者其更多的作用
115. {
116. current = current->next;
117. k++;
118. }
119. //for(int k=0 ;k < i ;k++)//遍历到第i个
120. // current = current->next;
122. return current;//指向第i个元素的指针
123. }
124. template<class T>
125. bool List<T>::GetData(int i,T& x)const //参数中有下标值的一般先判断其下标值是否合法
126. {
127. if(i <= 0)
128. return false;
129. LinkNode<T> *current = Locate(i);
130. if(current == NULL)
131. return false;
132. x = current->data;
133. retrun true;
134. }
136. template<class T>
137. bool List<T>::SetData(int i,T& x)
138. {
139. if(i <= 0)
140. return false;
141. LinkNode<T> *current = Locate(i);
142. if(current == NULL)
143. return false;
144. current->data = x;
145. return true;
146. }
147. template<class T>
148. bool List<T>::Insert(int i,T& x)
149. {
150. if(i < 0 )//可以插入在第一个结点之前,有头结点的好处代码一致
151. return false;
152. LinkNode<T> *current = Locate(i);
153. return false;
154. LinkNode<T> *newNode = new LinkNode<T>(x);
155. if(newNode == NULL)
156. return false;
158. newNode->prior = current; //双向链表插入的关键四步，顺序不能变，最后一句必须最后执行
159. newNode->next = current->next;
160. current->next->prior = newNode;
161. current->next = newNode;
163. return true;
164. }
165. template<class T>
166. LinkNode<T>* List<T>::Remove(int i,T& x)
167. {
168. if(i <= 0)
169. return NULL;
170. LinkNode<T> *current = Locate(i);//和单链表不同的是,双向链表有前指针可以指向前驱,所以定位到第i个就好
171. if(current ==NULL)
172. return NULL;
173. current->next->prior = current->prior;//双向链表删除操作较为简单明了
174. current->prior->next = current->next;//重新搭链
175. x = current->data;
177. delete current;//销毁指针资源
178. }
180. template<class T>
181. bool List<T>::isEmpty()const
182. {
183. return ((first->next == NULL) ?true : false);
184. }
186. template<class T>
187. void List<T>::input(T endTag)
188. {
189. LinkNode<T> *newNode,*last = first;
190. T value;
191. cin>>value;
192. while(value != endTag)
193. {
194. newNode = new LinkNode<T>(value);
196. newNode->prior = last;
197. last->next = newNode;
199. last = newNode;
200. cin>>value;
201. }
202. }
204. template<class T>
205. void List<T>::output()//输出
206. {
207. cout<<"双向链表输出如下:"<<endl;
208. LinkNode<T> *current = first->next;
209. int count = 0;
210. while(current != NULL)
211. {
212. cout<<"#"<<count+1<<":"<<current->data<<endl;
213. current = current->next;
214. count++;
215. }
216. }
217. template<class T>
218. void List<T>::Sort()//最小选择 排序
219. {
220. LinkNode<T> *current1,*current2;//下面连续取后继指针把外层循环控制在倒数第二个结点
221. for(current1 = first->next ; current1->next != NULL ; current1 = current1->next)
222. {
223. for(current2 = current1->next ; current2 != NULL ; current2 = current2->next)
224. {
225. if(current1->data > current2->data)
226. {
227. T temp;
228. temp = current1->data;
229. current1->data = current2->data;
230. current2->data = temp;
231. }
232. }
233. }
234. }
235. template<class T>
236. void List<T>::operator= (List<T> &L)
237. {
238. makeEmpty();//先全部销毁指针资源
240. LinkNode<T> *srcptr = L.getHead() ->next; //获取头指针 用于遍历
241. LinkNode<T> *destptr = first; //= new LinkNode<T>;//不用于赋值初始化,只用于复制,不用建立新头结点
242. LinkNode<T> *newNode;
243. T value;
244. while(srcptr != NULL)//直到最后一个结点的尾指针为空结束
245. {
246. value = srcptr->data;
247. newNode = new LinkNode<T>(value);
249. newNode->prior = destptr;//往新链表的后面插入
250. destptr->next = newNode;
252. srcptr = srcptr->next;//后移
253. destptr = destptr->next;
254. }
255. }

#pragma once
//#include"LinearList.h"
#include"LinkNode.h"
#include<iostream>
using namespace std;
template<class T>//继承的过程中，加上此句派生类依然为类模板
class List
{
protected:
	LinkNode<T>* first;//封装
public:
	List();
	//List(const T& x);//感觉没用到过
	List(List<T>& L);
	~List();
	void makeEmpty();//依次销毁每个结点的空间
	 
	int Length() const;//搜索当前表节点数
	LinkNode<T>* getHead() const;//返回头指针
    LinkNode<T>* Search(T x) const;//搜索并返回指针
	LinkNode<T>* Locate(int i) const;//定位并返回指针

	bool GetData(int i,T& x) const;//返回第i个结点的元素值以引用的形式
	bool SetData(int i,T& x);//修改第i个结点的元素值
	bool Insert(int i,T& x);//在第i个节点后面插入新节点元素值
	LinkNode<T>* Remove(int i,T& x);//删除第i个结点

	bool isEmpty() const;//判表空

	void Sort(); //排序
	void input(T endTag);//建立表并输入
	void output();//输出表
	void operator = (List<T>& L);//复制重载
};

template<class T>
List<T>::List()
{
	first = new LinkNode<T>;//构造函数中开辟头结点
}

template<class T>
List<T>::List(List<T>& L)
{
	LinkNode<T> *srcptr = L.getHead() ->next; //获取头指针 用于遍历
	LinkNode<T> *destptr = first = new LinkNode<T>;//建立头结点 初始化
	LinkNode<T> *newNode;
	T value;
	while(srcptr != NULL)//直到最后一个结点的尾指针为空结束
	{
		value = srcptr->data;
		newNode = new LinkNode<T>(value);

		newNode->prior = destptr;//往新链表的后面插入
		destptr->next = newNode;

		srcptr = srcptr->next;//后移
		destptr = destptr->next;
	}
}
template<class T>
List<T>::~List()
{}

template<class T>
void List<T>::makeEmpty() //全部销毁指针资源
{
	LinkNode<T> *current = first->next;
	LinkNode<T> *del;
	while(current != NULL)
	{
		del = current;
		current = current->next;
		delete del;
	}
}

template<class T>
int List<T>::Length() const
{
	int count = 0;
	LinkNode<T> *current = first;//头指针副本用于遍历
	while(current->next != NULL)//与单链表的遍历控制条件相同，当前结点后后继是否为空
	{
		current = current->next;
		count++ ;
	}
	return count;
}

template<class T>
LinkNode<T>* List<T>::getHead() const
{
	return first;
}
template<class T>
LinkNode<T>* List<T>::Search(T x) const
{
	LinkNode<T> *current = first->next;
	while(current != NULL)//此时的控制条件为某个结点的next知否为空
	{
		if(current->data == x)
			return current;//如果查询到直接函数返回,不用无用操作(如果链表中有多个x元素值,则以第一个为准返回)
		current = current->next;
	}
	return NULL;
}
template<class T>
LinkNode<T>* List<T>::Locate(int i) const
{
	if(i < 0)     //定位可以是第0个，也就是头结点指针
		return NULL;
	LinkNode<T> *current = first;int k=0;
	while(current != NULL && k < i)//双条件控制后者其更多的作用
	{
		current = current->next;
		k++;
	}
	//for(int k=0 ;k < i ;k++)//遍历到第i个
	//	current = current->next;

	return current;//指向第i个元素的指针
}
template<class T>
bool List<T>::GetData(int i,T& x) const   //参数中有下标值的一般先判断其下标值是否合法
{
	if(i <= 0)
		return false;
	LinkNode<T> *current = Locate(i);
	if(current == NULL)
		return false;
	x = current->data;
	retrun true;
}

template<class T>
bool List<T>::SetData(int i,T& x)
{
	if(i <= 0)
		return false;
	LinkNode<T> *current = Locate(i);
	if(current == NULL)
		return false;
	current->data = x;
	return true;
}
template<class T>
bool List<T>::Insert(int i,T& x)
{
	if(i < 0 )//可以插入在第一个结点之前,有头结点的好处代码一致
		return false;
	LinkNode<T> *current = Locate(i);
	return false;
	LinkNode<T> *newNode = new LinkNode<T>(x);
	if(newNode == NULL)
		return false;

	newNode->prior = current; //双向链表插入的关键四步，顺序不能变，最后一句必须最后执行
	newNode->next = current->next;
	current->next->prior = newNode;
	current->next = newNode;

	return true;
}
template<class T>
LinkNode<T>* List<T>::Remove(int i,T& x)
{
	if(i <= 0)
		return NULL;
	LinkNode<T> *current = Locate(i);//和单链表不同的是,双向链表有前指针可以指向前驱,所以定位到第i个就好
	if(current ==NULL)
		return NULL;
	current->next->prior = current->prior;//双向链表删除操作较为简单明了
	current->prior->next = current->next;//重新搭链
	x = current->data;

	delete current;//销毁指针资源
}

template<class T>
bool List<T>::isEmpty() const
{
	return ((first->next == NULL) ? true : false);
}

template<class T>
void List<T>::input(T endTag)
{
	LinkNode<T> *newNode,*last = first;
	T value;
	cin>>value;
	while(value != endTag)
	{
		newNode = new LinkNode<T>(value);

		newNode->prior = last;
		last->next = newNode;

		last = newNode;
		cin>>value;
	}
}

template<class T>
void List<T>::output()//输出
{
	cout<<"双向链表输出如下:"<<endl;
	LinkNode<T> *current = first->next;
	int count = 0;
	while(current != NULL)
	{
		cout<<"#"<<count+1<<":"<<current->data<<endl;
		current = current->next;
		count++;
	}
}
template<class T>
void List<T>::Sort()//最小选择 排序
{
	LinkNode<T> *current1,*current2;//下面连续取后继指针把外层循环控制在倒数第二个结点
	for(current1 = first->next ; current1->next != NULL ; current1 = current1->next)
	{
		for(current2 = current1->next ; current2 != NULL ; current2 = current2->next)
		{
			if(current1->data > current2->data)
			{
				T temp;
				temp = current1->data;
				current1->data = current2->data;
				current2->data = temp;
			}
		}
	}
}
template<class T>
void List<T>::operator= (List<T> &L)
{
	makeEmpty();//先全部销毁指针资源

	LinkNode<T> *srcptr = L.getHead() ->next; //获取头指针 用于遍历
	LinkNode<T> *destptr = first;   //= new LinkNode<T>;//不用于赋值初始化,只用于复制,不用建立新头结点
	LinkNode<T> *newNode;
	T value;
	while(srcptr != NULL)//直到最后一个结点的尾指针为空结束
	{
		value = srcptr->data;
		newNode = new LinkNode<T>(value);

		newNode->prior = destptr;//往新链表的后面插入
		destptr->next = newNode;

		srcptr = srcptr->next;//后移
		destptr = destptr->next;
	}
}