图的表示方法C++实现

图的表示最长用的两种方法是：

1）、邻接矩阵表示法

2）、邻接表表示

下面是两种构造图的方法

1）邻接矩阵：

[cpp]  view plain copy

1. #include <iostream>  
2. #include <vector>  
3. using namespace std;  
4.   
5. //枚举类型，图的种类 DG：有向图；WDG：带权值的有向图；  
6. //UDG: 无向图；WUDG: 带权值的无向图  
7. enum GraphKind {DG, WDG, UDG, WUDG};  
8.   
9. //vertexType顶点类型，VRType：顶点之间的关系类型，InfoType：弧的信息类型  
10. template <typename VertexType, typename VRType, typename InfoType>  
11. class MGraph  
12. {  
13. public:  
14.     MGraph(int vexNum, GraphKind __kind) : vexnum(vexNum), arcnum(0), kind(__kind)  
15.     {  
16.         //分配顶点向量数组  
17.         vvec = new VertexType[vexnum];  
18.         //动态分配二维数组， 注意二维数组的动态分配  
19.         arcs = new ArcCell *[vexnum];  
20.         for (int i = 0; i < vexnum; i++)  
21.         {  
22.             //为每一行动态分配空间  
23.             arcs[i] = new ArcCell[vexnum];  
24.         }  
25.     }  
26.   
27.     void Create()  
28.     {  
29.         switch (kind)  
30.         {  
31.         case DG:   
32.             {  
33.                 CreateDG();    //构造一个有向图  
34.                 break;  
35.             }             
36.         case WDG:  
37.             {  
38.                 CreateWDG();    //构造一个带权有向图  
39.                 break;  
40.             }  
41.         case UDG:  
42.             {  
43.                 CreateUDG();    //构造一个无向图  
44.                 break;  
45.             }  
46.         case WUDG:  
47.             {   
48.                 CreateWUDG();   //构造一个带权无向图  
49.                 break;  
50.             }  
51.         default:  
52.             return;  
53.         }  
54.     }  
55.   
56.     //初始化顶点数组和邻接矩阵  
57.     void Init()  
58.     {  
59.         cout << "请输入每个顶点的关键字：" << endl;  
60.         VertexType val;  
61.         for (int i = 0; i < vexnum; i++)  
62.         {  
63.             cin >> val;  
64.             vvec[i] = val;  
65.         }  
66.         for (int i = 0; i < vexnum; i++)  
67.         {  
68.             ArcCell ac;  
69.             ac.adj = 0;  
70.             ac.info = NULL;  
71.             for (int j = 0; j < vexnum; j++)  
72.             {             
73.                 arcs[i][j] = ac;  
74.             }  
75.         }  
76.     }  
77.   
78.     //构造一个有向图  
79.     void CreateDG()  
80.     {  
81.         Init();  
82.         int vhead, vtail;  
83.         cout << "请依次输入每条边的开始顶点和结束顶点：" << endl;  
84.         while (cin >> vhead >> vtail)  
85.         {  
86.             arcnum++;  
87.             arcs[vhead][vtail].adj = 1;  
88.         }  
89.     }  
90.   
91.     //构造一个带权有向图  
92.     void CreateWDG()  
93.     {  
94.         Init();  
95.         int vhead, vtail;  
96.         InfoType w;  
97.         cout << "请依次输入每条边的开始顶点和结束顶点和权值：" << endl;  
98.         while (cin >> vhead >> vtail >> w)  
99.         {  
100.             arcnum++;  
101.             arcs[vhead][vtail].adj = w;  
102.         }  
103.     }  
104.   
105.     //构造一个无向图  
106.     void CreateUDG()  
107.     {  
108.         Init();  
109.         int vhead, vtail;  
110.         cout << "请依次输入每条边的开始顶点和结束顶点：" << endl;  
111.         while (cin >> vhead >> vtail)  
112.         {  
113.             arcnum += 2;  
114.             arcs[vhead][vtail].adj  = 1;  
115.             arcs[vtail][vhead].adj  = 1;  
116.         }  
117.     }  
118.   
119.     //构造一个带权无向图  
120.     void CreateWUDG()  
121.     {  
122.         Init();  
123.         int vhead, vtail;  
124.         InfoType w;  
125.         cout << "请依次输入每条边的开始顶点和结束顶点和权值：" << endl;  
126.         while (cin >> vhead >> vtail >> w)  
127.         {  
128.             arcnum += 2;  
129.             arcs[vhead][vtail].adj = w;  
130.             arcs[vtail][vhead].adj = w;  
131.         }  
132.     }  
133.   
134.     void displayGraph()  
135.     {  
136.         cout << "总共有" << vexnum << "个顶点，"   
137.              << arcnum << "条边" << endl;  
138.         for (int i = 0; i < vexnum; i++)  
139.         {  
140.             cout << "第" << i+1 << "个顶点是：" << vvec[i]   
141.                  << "相邻的边有: ";  
142.             for (int j = 0; j < vexnum; j++)  
143.             {  
144.                 if (arcs[i][j].adj != 0)  
145.                     cout << vvec[j] << "(" << arcs[i][j].adj << ") ";   
146.             }  
147.             cout << endl;  
148.         }  
149.     }  
150.   
151. private:  
152.     struct ArcCell  
153.     {  
154.         VRType adj;   //顶点关系类型。对于无权图，用1或0表示  
155.                       //表示相邻与否；对带权图，为权值类型  
156.         InfoType info;  //该弧相关的信息的指针  
157.     };  
158.     VertexType *vvec;          //顶点向量  
159.     ArcCell **arcs;    //邻接矩阵  
160.     int vexnum;                       //图的当前顶点个数  
161.     int arcnum;                       //图的弧数  
162.     GraphKind kind;                   //图的种类标志  
163. };  
164.   
165. int main()  
166. {  
167.     cout << "构造无向图：" << endl;  
168.     MGraph<char, int, int> udgGraph(8, UDG);  
169.     udgGraph.Create();  
170.     udgGraph.displayGraph();  
171.   
172.     cout << "构造带权无向图：" << endl;  
173.     MGraph<char, int, int> wudgGraph(9, WUDG);  
174.     wudgGraph.Create();  
175.     wudgGraph.displayGraph();  
176.   
177.     cout << "构造有向图：" << endl;  
178.     MGraph<char, int, int> dgGraph(6, DG);  
179.     udgGraph.Create();  
180.     udgGraph.displayGraph();  
181.   
182.     cout << "构造带权有向图：" << endl;  
183.     MGraph<char, int, int> wdgGraph(6, WDG);  
184.     wdgGraph.Create();  
185.     wdgGraph.displayGraph();  
186.   
187.     system("pause");  
188.     return 0;  
189. }  

运行了一个带权有向图：

2）邻接链表

[cpp]  view plain copy

1. #include <iostream>  
2. using namespace std;  
3.   
4. //枚举类型，图的种类 DG：有向图；WDG：带权值的有向图；  
5. //UDG: 无向图；WUDG: 带权值的无向图  
6. enum GraphKind {DG, WDG, UDG, WUDG};  
7.   
8. template<typename VertexType, typename InfoType>  
9. class ALGraph  
10. {  
11. public:  
12.     ALGraph(int verNum, GraphKind _kind)   
13.         : vexnum(verNum), arcnum(0), kind(_kind)    
14.     {  
15.         for (int i = 0; i < MAX_VERTEX_NUM; i++)  
16.             vertices[i].firstarc = NULL;  
17.     }  
18.   
19.     //构造图，进行选择  
20.     void Create()  
21.     {  
22.         switch (kind)  
23.         {  
24.         case DG:   
25.             {  
26.                 CreateDG();    //构造一个有向图  
27.                 break;  
28.             }             
29.         case WDG:  
30.             {  
31.                 CreateWDG();    //构造一个带权有向图  
32.                 break;  
33.             }  
34.         case UDG:  
35.             {  
36.                 CreateUDG();    //构造一个无向图  
37.                 break;  
38.             }  
39.         case WUDG:  
40.             {   
41.                 CreateWUDG();   //构造一个带权无向图  
42.                 break;  
43.             }  
44.         default:  
45.             return;  
46.         }  
47.     }  
48.       
49.     //打印邻接链表  
50.     void displayGraph()  
51.     {  
52.         for (int i = 0; i < vexnum; i++)  
53.         {  
54.             cout << "第" << i+1 << "个顶点是：" << vertices[i].data  
55.                 << " 邻接表为: ";  
56.             ArcNode *arcNode = vertices[i].firstarc;  
57.             while (arcNode != NULL)  
58.             {  
59.                 cout << " -> " << vertices[arcNode->adjvex].data  
60.                     << "(" << arcNode->info << ")";  
61.                 arcNode = arcNode->nextarc;  
62.             }  
63.             cout << endl;  
64.         }  
65.     }  
66.   
67. private:  
68.     //初始化邻接链表的表头数组  
69.     void InitVertics()  
70.     {  
71.         cout << "请输入每个顶点的关键字：" << endl;  
72.         VertexType val;  
73.         for (int i = 0; i < vexnum; i++)  
74.         {  
75.             cin >> val;  
76.             vertices[i].data = val;  
77.         }  
78.     }  
79.   
80.     //插入一个表结点  
81.     void insertArc(int vHead, int vTail, InfoType w)  
82.     {  
83.         //构造一个表结点  
84.         ArcNode *newArcNode = new ArcNode;  
85.         newArcNode->adjvex = vTail;  
86.         newArcNode->nextarc = NULL;  
87.         newArcNode->info = w;  
88.   
89.         //arcNode 是vertics[vHead]的邻接表  
90.         ArcNode *arcNode = vertices[vHead].firstarc;  
91.         if (arcNode == NULL)  
92.             vertices[vHead].firstarc = newArcNode;  
93.         else  
94.         {  
95.             while (arcNode->nextarc != NULL)  
96.             {  
97.                 arcNode = arcNode->nextarc;        
98.             }  
99.             arcNode->nextarc = newArcNode;  
100.         }  
101.         arcnum++;  
102.     }  
103.   
104.     //构造一个有向图  
105.     void CreateDG()  
106.     {  
107.         InitVertics();  
108.         int vhead, vtail;  
109.         cout << "请依次输入每条边的开始顶点和结束顶点：" << endl;  
110.         while (cin >> vhead >> vtail)  
111.         {  
112.             insertArc(vhead, vtail, 0);  
113.         }  
114.     }  
115.   
116.     //构造一个带权有向图  
117.     void CreateWDG()  
118.     {  
119.         InitVertics();  
120.         int vhead, vtail;  
121.         InfoType w;  
122.         cout << "请依次输入每条边的开始顶点和结束顶点和权值：" << endl;  
123.         while (cin >> vhead >> vtail >> w)  
124.         {  
125.             insertArc(vhead, vtail, w);  
126.         }  
127.     }  
128.   
129.     //构造一个无向图  
130.     void CreateUDG()  
131.     {  
132.         InitVertics();  
133.         int vhead, vtail;  
134.         cout << "请依次输入每条边的开始顶点和结束顶点：" << endl;  
135.         while (cin >> vhead >> vtail)  
136.         {  
137.             insertArc(vhead, vtail, 0);  
138.             insertArc(vtail, vhead, 0);  
139.         }  
140.     }  
141.   
142.     //构造一个带权无向图  
143.     void CreateWUDG()  
144.     {  
145.         InitVertics();  
146.         int vhead, vtail;  
147.         InfoType w;  
148.         cout << "请依次输入每条边的开始顶点和结束顶点和权值：" << endl;  
149.         while (cin >> vhead >> vtail >> w)  
150.         {  
151.             insertArc(vhead, vtail, w);  
152.             insertArc(vtail, vhead, w);  
153.         }  
154.     }  
155.   
156.   
157.     //const数据成员必须在构造函数里初始化  
158.     static const int MAX_VERTEX_NUM = 20;  //最大顶点个数  
159.   
160.   
161.     struct ArcNode          //表结点  
162.     {  
163.         int adjvex;        //该弧所指向的顶点的位置  
164.         ArcNode *nextarc;  //指向下一条弧的指针  
165.         InfoType info;     //该弧相关信息的指针  
166.     };  
167.     struct VNode           //头结点  
168.     {  
169.         VertexType data;    //顶点信息  
170.         ArcNode *firstarc;  //指向第一条依附于该顶点的弧的指针  
171.     };  
172.   
173.     /*VNode AdjList[MAX_VERTEX_NUM];*/   
174.     /* AdjList[MAX_VERTEX_NUM] vertices;*/  
175.     VNode vertices[MAX_VERTEX_NUM];  
176.     int vexnum;             //图的当前顶点数  
177.     int arcnum;             //图的弧数  
178.     GraphKind kind;         //图的种类   
179. };  
180.   
181. int main()  
182. {  
183.     cout << "构造一个8个顶点的无向图:" << endl;  
184.     ALGraph<char, int> udgGraph(8, UDG);  
185.     udgGraph.Create();  
186.     udgGraph.displayGraph();  
187.   
188.     cout << "构造一个9个顶点的带权无向图:" << endl;  
189.     ALGraph<char, int> wudgGraph(9, WUDG);  
190.     wudgGraph.Create();  
191.     wudgGraph.displayGraph();  
192.   
193.     cout << "构造一个6个顶点的有向图:" << endl;  
194.     ALGraph<char, int> dgGraph(6, DG);  
195.     dgGraph.Create();  
196.     dgGraph.displayGraph();  
197.   
198.     cout << "构造一个9个顶点的带权有向图:" << endl;  
199.     ALGraph<char, int> wdgGraph(9, WDG);  
200.     wdgGraph.Create();  
201.     wdgGraph.displayGraph();  
202.   
203.     system("pause");  
204.     return 0;  
205. }