【数据结构】十字链表

上篇文章讲解了图的邻接表的链式存储方式，这篇文章讲解图的十字链存储方式。

基本概念

十字链表是为了便于求得图中顶点的度（出度和入度）而提出来的。它是综合邻接表和逆邻接表形式的一种链式存储结构。

在十字链表存储结构中，有向图中的顶点的结构如下所示：

其中data表示顶点的具体数据信息，而firstIn则表示指向以该顶点为弧头的第一个弧节点。而firstOut则表示指向以该顶点为弧尾的第一个弧节点。为了表示有向图中所有的顶点，采用一个顶点数组存储每一个结点，如下图所示。

另外，在十字链表存储结构中，有向图中的每一条弧都有一个弧结点与之对应，具体的弧结点结构如下所示：

 

其中的tailVex表示该弧的弧尾顶点在顶点数组xList中的位置，headVex表示该弧的弧头顶点在顶点数组中的位置。hLink则表示指向弧头相同的下一条弧，tLink则表示指向弧尾相同的下一条弧。

从十字链表的数据结构来看，每一个顶点对应两个链表：以该顶点为弧尾的弧结点所组成的链表以及以该顶点为弧头的弧结点所组成的链表。

如下图所示的一个有向图：

其对应的顶点以及弧结点如下所示。拿结点A说明，该结点对应两个链表（绿色和黄色标记的）。绿色链表表示以结点Ａ为弧头的弧组成的链表。黄色链表表示以结点Ａ为弧尾的弧组成的链表。

 

基本操作

 

1、创建图的十字链表

1. Status createDG(OLGraph &G, int vexNum, int arcNum){
2. G.vexNum = vexNum;
3. G.arcNum = arcNum;
5. for(int i = 0; i<G.vexNum; i++){
6. cin>>G.xList[i].data;
7. G.xList[i].firstIn = NULL;
8. G.xList[i].firstOut = NULL;
9. }//初始化
11. for(int i = 0; i<G.arcNum; i++){
12. vexNode node1, node2;
13. cout<<“please input two nodes of “<<i+1<<“-th arc”<<endl;
14. cin>>node1.data>>node2.data;
16. insertArc(G, node1, node2);
17. }
18. return 1;
19. }

测试结果：

如下图所示首先输入四个顶点：A、B、C、D，然后输入7条弧。

既可以构建如下的有向图。

 

2、按照十字链表形式打印图

1. Status printDG(OLGraph &G){
2. for(int i = 0; i<G.vexNum; i++){
3. arcBox *ptail = G.xList[i].firstOut;
4. arcBox *phead = G.xList[i].firstIn;
6. //打印以结点i为弧尾的链
7. cout<<“以结点”<<i<<“为弧尾的链 “<<G.xList[i].data;
8. while(ptail){
9. cout<<“–>”<<“|”<<ptail->tailVex<<“|”<<ptail->headVex;
10. ptail = ptail-> tLink;
11. }
12. cout<<“–>NULL”<<endl;
14. //打印以结点i为弧头的链
16. cout<<“以结点”<<i<<“为弧头的链 “<<G.xList[i].data;
17. while(phead){
18. cout<<“–>”<<“|”<<phead->tailVex<<“|”<<phead->headVex;
19. phead = phead->hLink;
20. }
21. cout<<“–>NULL”<<endl;
22. }
23. return 1;
24. }

测试结果：

每一个顶点对应两个链表（以该结点为弧头的链表和以该结点位弧尾的链表），分别将其打印出来。

3、向图中插入一个结点

1. Status insertNode(OLGraph &G, vexNode node){
3. G.xList[G.vexNum].data = node.data;
4. G.xList[G.vexNum].firstIn = NULL;
5. G.xList[G.vexNum].firstOut = NULL;
6. G.vexNum = G.vexNum + 1;
7. return 1;
8. }

测试结果：

向原来的有向图插入一个新的结点E。新插入的节点没有与之前图中的顶点建立弧，因此其打印结果如下所示。

此时有向图变成了：

4、向图中结点之间插入一条弧

 

1. void insertArcAction(OLGraph &G, int index1, int index2){
3. arcBox* pArc = new arcBox[1];
4. pArc->tailVex = index1;
5. pArc->headVex = index2;
6. pArc->info = NULL;
8. arcBox *ptail = G.xList[index1].firstOut;
9. arcBox *phead = G.xList[index2].firstIn;
11. if(!ptail){pArc->tLink = NULL;}
12. else{pArc->tLink = ptail;}
14. if(!phead){pArc->hLink = NULL;}
15. else{pArc->hLink = phead;}
17. G.xList[index1].firstOut = pArc;//链头部插入弧结点
18. G.xList[index2].firstIn = pArc;
19. }
21. Status insertArc(OLGraph &G, vexNode node1, vexNode node2){
23. int index1 = locateVertex(G, node1);
24. int index2 = locateVertex(G, node2);
26. insertArcAction(G, index1, index2);
27. return 1;
28. }

 

测试结果：

插入一条结点B到结点C的弧。再次打印该有向图时，结果如下所示。

此时有向图变成了：

 

5、删除一条弧

1. void deleteOutArcAction(OLGraph &G, int index1, int index2){
2. arcBox *cur = G.xList[index1].firstOut;
3. arcBox *pre = cur;
5. int count = 0;
6. if(!cur)
7. return;
8. else{
9. while(cur){
10. count++;
11. if(cur->headVex == index2)
12. break;
13. pre = cur;
14. cur = cur->tLink;
15. }
16. }
17. if(!cur)
18. return;//该结点没有对应的弧
19. else if(count <=1)
20. G.xList[index1].firstOut = pre->tLink;//删除第一个弧结点
21. else
22. pre->tLink = cur->tLink;//删除非第一个弧结点
23. }
25. void deleteInArcAction(OLGraph &G, int index1, int index2){
26. arcBox *cur = G.xList[index2].firstIn;
27. arcBox *pre = cur;
29. int count = 0;
30. if(!cur)
31. return;
32. else{
33. while(cur){
34. count++;
35. if(cur->tailVex == index1)
36. break;
37. pre = cur;
38. cur = cur->hLink;
39. }
40. }
41. if(!cur)
42. return;//该结点没有对应的弧
43. else if(count <=1)
44. G.xList[index2].firstIn = pre->hLink;
45. else
46. pre->hLink = cur->hLink;
47. }
49. Status deleteArc(OLGraph &G, vexNode node1, vexNode node2){
50. //删除从结点1到结点2的弧（有方向）
51. int index1 = locateVertex(G, node1);
52. int index2 = locateVertex(G, node2);
54. deleteOutArcAction(G, index1, index2);//删除两条链表里面的值
55. deleteInArcAction(G, index1, index2);
57. return 1;
58. }

测试结果：

删除从结点A到结点B的弧。重新打印该有向图，结果如下所示：

此时有向图变成了：

 

6、删除一个顶点

1. Status deleteNode(OLGraph &G, vexNode node){
2. //删除结点后，该xList顶点数组中该结点后面的结点不前移，而只是将该被删除的结点的data设置成为一个较大的值
3. int index = locateVertex(G, node);
5. for(int i = 0; i<G.vexNum; i++){
6. if(i == index)
7. continue;
8. else{
9. deleteArc(G, G.xList[index], G.xList[i]);//删除以该结点为弧尾的弧
10. deleteArc(G, G.xList[i], G.xList[index]);//删除以该结点为弧头的弧
11. }
12. }
13. G.xList[index].data = ‘0’;//置’0’表示该结点被删除
14. G.xList[index].firstIn = NULL;
15. G.xList[index].firstOut = NULL;
17. return 1;
18. }

测试结果：

删除结点D，重新打印该有向图，其结果如下所示（只剩下3条弧，4个有效结点，结点D被删除后，该结点的内容变从‘D’变为‘0’）：

测试有向图变成了：

7、全部代码

1. // 十字链表.cpp : Defines the entry point for the console application.
2. //
4. #include “stdafx.h”
5. #include <iostream>
7. using namespace std;
9. #define MAX_VERTEX_NUM 20
11. typedef int Status;
12. typedef int infoType;
13. typedef char vertexType;
15. typedef struct arcBox{
16. int tailVex, headVex;
17. struct arcBox *hLink, *tLink;
18. infoType *info;
19. }arcBox;//弧结点
21. typedef struct vexNode{
22. vertexType data;
23. arcBox *firstIn, *firstOut;
24. }vexNode;//顶点节点
26. typedef struct{
27. vexNode xList[MAX_VERTEX_NUM];
28. int vexNum, arcNum;
29. }OLGraph;//十字链
31. int locateVertex(OLGraph &G, vexNode node){
32. int index = -1;
33. for(int i = 0; i<G.vexNum; i++){
34. if(node.data == G.xList[i].data){
35. index = i;
36. break;
37. }
38. }
39. return index;
40. }
42. void insertArcAction(OLGraph &G, int index1, int index2);
43. Status insertArc(OLGraph &G, vexNode node1, vexNode node2);
45. Status createDG(OLGraph &G, int vexNum, int arcNum){
46. G.vexNum = vexNum;
47. G.arcNum = arcNum;
49. for(int i = 0; i<G.vexNum; i++){
50. cin>>G.xList[i].data;
51. G.xList[i].firstIn = NULL;
52. G.xList[i].firstOut = NULL;
53. }//初始化
55. for(int i = 0; i<G.arcNum; i++){
56. vexNode node1, node2;
57. cout<<“please input two nodes of “<<i+1<<“-th arc”<<endl;
58. cin>>node1.data>>node2.data;
60. insertArc(G, node1, node2);
61. }
62. return 1;
63. }
65. Status printDG(OLGraph &G){
66. for(int i = 0; i<G.vexNum; i++){
67. arcBox *ptail = G.xList[i].firstOut;
68. arcBox *phead = G.xList[i].firstIn;
70. //打印以结点i为弧尾的链
71. cout<<“以结点”<<i<<“为弧尾的链 “<<G.xList[i].data;
72. while(ptail){
73. cout<<“–>”<<“|”<<ptail->tailVex<<“|”<<ptail->headVex;
74. ptail = ptail-> tLink;
75. }
76. cout<<“–>NULL”<<endl;
78. //打印以结点i为弧头的链
80. cout<<“以结点”<<i<<“为弧头的链 “<<G.xList[i].data;
81. while(phead){
82. cout<<“–>”<<“|”<<phead->tailVex<<“|”<<phead->headVex;
83. phead = phead->hLink;
84. }
85. cout<<“–>NULL”<<endl;
86. }
87. return 1;
88. }
90. void insertArcAction(OLGraph &G, int index1, int index2){
92. arcBox* pArc = new arcBox[1];
93. pArc->tailVex = index1;
94. pArc->headVex = index2;
95. pArc->info = NULL;
97. arcBox *ptail = G.xList[index1].firstOut;
98. arcBox *phead = G.xList[index2].firstIn;
100. if(!ptail){pArc->tLink = NULL;}
101. else{pArc->tLink = ptail;}
103. if(!phead){pArc->hLink = NULL;}
104. else{pArc->hLink = phead;}
106. G.xList[index1].firstOut = pArc;//链头部插入弧结点
107. G.xList[index2].firstIn = pArc;
108. }
110. Status insertArc(OLGraph &G, vexNode node1, vexNode node2){
112. int index1 = locateVertex(G, node1);
113. int index2 = locateVertex(G, node2);
115. insertArcAction(G, index1, index2);
116. return 1;
117. }
119. Status insertNode(OLGraph &G, vexNode node){
121. G.xList[G.vexNum].data = node.data;
122. G.xList[G.vexNum].firstIn = NULL;
123. G.xList[G.vexNum].firstOut = NULL;
124. G.vexNum = G.vexNum + 1;
125. return 1;
126. }
128. Status deleteArc(OLGraph &G, vexNode node1, vexNode node2);
130. Status deleteNode(OLGraph &G, vexNode node){
131. //删除结点后，该xList顶点数组中该结点后面的结点不前移，而只是将该被删除的结点的data设置成为一个较大的值
132. int index = locateVertex(G, node);
134. for(int i = 0; i<G.vexNum; i++){
135. if(i == index)
136. continue;
137. else{
138. deleteArc(G, G.xList[index], G.xList[i]);//删除以该结点为弧尾的弧
139. deleteArc(G, G.xList[i], G.xList[index]);//删除以该结点为弧头的弧
140. }
141. }
142. G.xList[index].data = ‘0’;//置’0’表示该结点被删除
143. G.xList[index].firstIn = NULL;
144. G.xList[index].firstOut = NULL;
146. return 1;
147. }
149. void deleteOutArcAction(OLGraph &G, int index1, int index2){
150. arcBox *cur = G.xList[index1].firstOut;
151. arcBox *pre = cur;
153. int count = 0;
154. if(!cur)
155. return;
156. else{
157. while(cur){
158. count++;
159. if(cur->headVex == index2)
160. break;
161. pre = cur;
162. cur = cur->tLink;
163. }
164. }
165. if(!cur)
166. return;//该结点没有对应的弧
167. else if(count <=1)
168. G.xList[index1].firstOut = pre->tLink;//删除第一个弧结点
169. else
170. pre->tLink = cur->tLink;//删除非第一个弧结点
171. }
173. void deleteInArcAction(OLGraph &G, int index1, int index2){
174. arcBox *cur = G.xList[index2].firstIn;
175. arcBox *pre = cur;
177. int count = 0;
178. if(!cur)
179. return;
180. else{
181. while(cur){
182. count++;
183. if(cur->tailVex == index1)
184. break;
185. pre = cur;
186. cur = cur->hLink;
187. }
188. }
189. if(!cur)
190. return;//该结点没有对应的弧
191. else if(count <=1)
192. G.xList[index2].firstIn = pre->hLink;
193. else
194. pre->hLink = cur->hLink;
195. }
197. Status deleteArc(OLGraph &G, vexNode node1, vexNode node2){
198. //删除从结点1到结点2的弧（有方向）
199. int index1 = locateVertex(G, node1);
200. int index2 = locateVertex(G, node2);
202. deleteOutArcAction(G, index1, index2);//删除两条链表里面的值
203. deleteInArcAction(G, index1, index2);
205. return 1;
206. }
208. int _tmain(int argc, _TCHAR* argv[])
209. {
210. int vexNum = 4;
211. int arcNum = 7;
213. OLGraph G;
215. cout<<“Try to create a Orthogonal List of a graph…”<<endl;
216. createDG(G, vexNum, arcNum);
217. cout<<“Try to print the Orthogonal List of the very graph…”<<endl;
218. printDG(G);
220. cout<<“Try to insert a node into the graph…”<<endl;
221. vexNode node;
222. cout<<” please input the data of the node to insert:”<<endl;
223. cin>>node.data;
224. insertNode(G, node);
225. printDG(G);
227. cout<<“Try to insert a arc into the graph…”<<endl;
228. vexNode node1, node2;
229. cout<<” please choose two node:”<<endl;
230. cin>>node1.data>>node2.data;
231. insertArc(G, node1, node2);
232. printDG(G);
234. cout<<“Try to delete the arc between two nodes…”<<endl;
235. vexNode node3, node4;
236. cout<<” please choose a arc with specifing two nodes:”<<endl;
237. cin>>node3.data>>node4.data;
238. deleteArc(G, node3, node4);
239. printDG(G);
241. cout<<“Try to delete a node of the graph…”<<endl;
242. vexNode node5;
243. cout<<” please choose a node:”<<endl;
244. cin>>node5.data;
245. deleteNode(G, node5);
246. printDG(G);
248. system(“pause”);
250. return 0;
251. }