#include <iostream>
#include <memory.h>
#include <stack>
#include <queue>
using namespace std;
class GraphList;
//边结点的结构体
struct Edge
{
friend class GraphList;
int VerAdj; //邻接顶点序号，从0开始编号
int cost; //边的权值
Edge*Link; //指向下一边节点的指针
Edge(int aVerAdj,int acost,Edge*aLink=NULL){ VerAdj=aVerAdj;cost=acost;Link=aLink;}
Edge(Edge*aLink=NULL){Link=aLink;}
};
//顶点表中结点的结构体
struct Vertex
{
friend class GraphList;
int VerName;//顶点名称
Edge*Adjacent;//边链表的头指针
Vertex(int name,Edge*adjacent=NULL){VerName=name;Adjacent=adjacent;}
Vertex(Edge*adjacent=NULL){Adjacent=adjacent;}
};
//采用邻接表储存的Graph_List类定义 其中所有边均为正权
class GraphList
{
private:
Vertex*Head; //顶点表头指针
int GraphSize; //图中当前顶点的个数
int MaxGraphSize; //图中最大顶点个数
int e; //图中当前边的个数
public:
GraphList(int MaxGraphSize);
virtual ~GraphList();
int IsEmpty() const{return !GraphSize;} //判断图是否为空
int IsFull()const{return GraphSize==MaxGraphSize;} //判断顶点数是否已满
int NumberOfVertices()const{return GraphSize;}//返回图中顶点的个数
int NumberOfEdges()const{return e;} //返回图中边的个数
int GetWeight(const int v1,const int v2)const;//返回指定边的权值
int GetFirstNeighbor(const int v)const;//返回序号为v的第一个邻接顶点的序号
int GetNextNeighbor(const int v1,const int v2)const;//返回序号为v1的顶点相对于序号为v2的点的下一个邻接顶点的序号
int GetNeighbors(const int v,int A[])const;//得到顶点v的邻接顶点表 返回邻接顶点个数
// bool InsertVertex(const int v);//向图中插入一个顶点
bool InsertEdge(const int v1,const int v2,int weight);//向图中插入一条边
// bool DeleteVertex(const int v);//在图中删除一个顶点
bool DeleteEdge(const int v1,const int v2);//在图中删除一条边
void DepthFirstSearch();//从顶点表的第一个顶点开始进行图的深度优先搜索
void DFS(const int v,int visited[]);//从顶点V开始进行图的深度优先搜索
void NDFS(const int v);//从顶点V开始进行图的深度优先搜索的迭代算法
void BFS(const int v);//从顶点V开始进行图的广度优先搜索
void Output();//输出邻接表
//void TopoOrder();//输出图的拓扑排序
//void CriticalPath();//输出图的关键路径
//void ShortestPath(const int v);//在非权图中求指定顶点到其他所有顶点的最短路径
//void DShortestPath(const int v);//在正权图中求指定定点到其他所有定点的最短路径
//void AllLength();//在正权图中求每对顶点间的最短路径
//void Prim();//构造图的最小支撑树的普里姆算法
//void Krustral();
};
//=============================================================================
//构造函数
GraphList::GraphList(int maxgraphsize):MaxGraphSize(maxgraphsize)
{
int from,to,weight;
//用数组实现顶点表，Head指向数组的第一个元素
Head=new Vertex[MaxGraphSize];
cout<<"请输入顶点数和边数"<<endl;
cin>>GraphSize;
cin>>e;
//初始化：
//顶点名字从0 -> GraphSize-1
for(int i=0;i<GraphSize;i++)
{
Head[i].VerName=i;
Head[i].Adjacent=NULL;
}
//空结点初始化
for(int i=GraphSize;i<MaxGraphSize;i++)
{
Head[i].VerName=-1;
Head[i].Adjacent=NULL;
}
for(int i=0;i<e;i++)
{
cout<<"输入始点，终点和权值：（这是第"<<i+1<<"条边) 空格隔开"<<endl;
cin>>from>>to>>weight;//输入新边的始点终点和权值
Edge*p=new Edge(to,weight,NULL);
Edge*q=Head[from].Adjacent;
if(q==NULL){
Head[from].Adjacent=p; //如果是第一条边
}else {
while(q->Link!=NULL) //如果不是第一条边，插到边结点最后
{
q=q->Link;
}
q->Link=p;
}
}
cout<<"创建成功！"<<endl;
}
//析构函数
GraphList::~GraphList()
{
for(int i=0;i<MaxGraphSize;i++)
{
Edge*p=Head[i].Adjacent;
while(p!=NULL)
{
Edge*q=p->Link;
delete p;
p=q;
}
}
delete []Head;
}
int GraphList::GetWeight(const int v1,const int v2)const //返回v1->v2的边的权
{
//如果其中一个顶点不存在
if(v1==-1||v2==-1) return 0;
Edge*p=Head[v1].Adjacent;
while(p!=NULL)
{
if(p->VerAdj==v2)
return p->cost;
p=p->Link;
}
return 0;
}
int GraphList::GetFirstNeighbor(const int v)const //返回第一个邻接点 若找不到则返回-1
{
if(v==-1||v>=GraphSize) return -1;
Edge*p=Head[v].Adjacent;
if(p!=NULL)
return p->VerAdj;
else return -1;
}
int GraphList::GetNextNeighbor(const int v1,const int v2)const //返回v1除了v2以外的下一个邻接点
{
if(v1==-1||v1>=GraphSize||v2==-1||v2>=GraphSize)
{
//cout<<"找不到"<<endl;
return -1;
}
Edge*p=Head[v1].Adjacent;
while(p!=NULL&&p->VerAdj!=v2)//找到v2
p=p->Link;
if(p==NULL||p->Link==NULL)
{
//cout<<"找不到"<<endl;
return -1;
}
p=p->Link;
return p->VerAdj;
}
int GraphList::GetNeighbors(const int v,int A[])const //得到顶点v的邻接顶点表 返回v的邻接顶点个数
{
if(v==-1||v>=GraphSize) return 0;
memset(A,0,sizeof(A));//初始化
int i=0;
Edge*p=Head[v].Adjacent;
while(p!=NULL)
{
A[i++]=p->VerAdj;
p=p->Link;
}
return i;
}
/*
bool GraphList::InsertVertex(const int v)//插入一个顶点
{
if(v<MaxGraphSize&&v>=0)
{
if(Head[v].VerName==-1)
{
Head[v].VerName=v;
GraphSize++;
return 1;
}
cout<<"顶点已存在";
return 0;
}
cout<<"越界，插入失败"<<endl;
return 0;
}
*/
bool GraphList::InsertEdge(const int v1,const int v2,int weight) //插入指定边
{
if(v1==-1||v2==-1||v1>=GraphSize||v2>=GraphSize) return 0;
Edge*q=new Edge(v2,weight,NULL);
Edge*p=Head[v1].Adjacent;
if(p==NULL){
Head[v1].Adjacent=q;
}else {
while(p->Link!=NULL&&p->VerAdj!=v2)
p=p->Link;
if(p->VerAdj==v2) return 0;//如果已经有这条边则插入失败
p->Link=q;
}
e++;
return 1;
}
bool GraphList::DeleteEdge(const int v1,const int v2)//删除指定边
{
if(v1==-1||v2==-1||v1>=GraphSize||v2>=GraphSize) return 0;
Edge*p=Head[v1].Adjacent;
Edge*q=Head[v1].Adjacent;
if(p!=NULL)
{
if(p->VerAdj==v2) //如果V2是第一个节点
{
Head[v1].Adjacent=p->Link;
delete p;
e--;
return 1;
}
//如果V2不是第一个节点
while(p!=NULL&&p->VerAdj!=v2)
{
q=p;
p=p->Link;
}
if(p==NULL)
{
//cout<<"无该边"<<endl;
return 0;
}
q->Link=p->Link;
delete p;
e--;
return 1;
}
//cout<<"无该边"<<endl;
return 0;
}
/*bool GraphList::DeleteVertex(const int v)
{
if(v<0||v>=MaxGraphSize||Head[v].VerName==-1) return -1;
//删除始点为v的边
Edge*p=Head[v].Adjacent;
while(p!=NULL)
{
Head[v].Adjacent=p->Link;
delete p;
e--;
p=Head[v].Adjacent;
}
//删除终点为v的边
for(int i=0;i<GraphSize;i++)
{
if(i==v) continue;
Edge*p=Head[i].Adjacent;
Edge*q;
while(p!=NULL)
{
q=p->Link;
if(q!=NULL&&q->VerAdj==v)
{
p->Link=q->Link;
delete q;
e--;
}
p=p->Link;
}
}
GraphSize--;
Head[v]=Vertex(-1);
return 1;
}
*/
//==============================================================
void GraphList::DepthFirstSearch()
{
int*visited=new int[GraphSize];
int i=0;
while(i<GraphSize)
{
visited[i++]=0;
}
DFS(0,visited);
delete[]visited;
}
void GraphList::DFS(int v,int visited[])
{
cout<<v<<" ";
visited[v]=1;
Edge*p=Head[v].Adjacent;
while(p!=NULL)
{
if(visited[p->VerAdj]!=1)
{
DFS(p->VerAdj,visited);
}
p=p->Link;
}
}
void GraphList::NDFS(int v)
{
//初始化
if(v==-1||v>=GraphSize) return;
int*visited=new int[GraphSize];
int i=0;
while(i<GraphSize) {visited[i++]=0;}
stack<int>S;
//访问顶点v
cout<<v<<" ";
visited[v]=1;
S.push(v);
int w;
while(!S.empty())
{
int v=S.top();
S.pop();
w=GetFirstNeighbor(v);
while(w!=-1)
{
if(!visited[w])
{
cout<<w<<" ";
visited[w]=1;
S.push(w);
}
w=GetNextNeighbor(v,w);
}
}
}
void GraphList::BFS(const int s)
{
//初始化
if(s==-1||s>=GraphSize) return;
int*visited=new int[GraphSize];
int i=0;
while(i<GraphSize) {visited[i++]=0;}
//访问顶点s
cout<<s<<" ";
visited[s]=1;
queue<int>q;
q.push(s);
while(!q.empty())
{
int v=q.front();
q.pop();
int w=GetFirstNeighbor(v);
while(w!=-1)
{
if(!visited[w])
{
cout<<w<<" ";
visited[w]=1;
q.push(w);
}
w=GetNextNeighbor(v,w);
}
}
delete []visited;
}
/*
void GraphList::TopoOrder()
{
//初始化
int n=GraphSize;
int *count=new int[n];
for(int i=0;i<n;i++) count[i]=0;
for(int i=0;i<n;i++)
{
Edge*p=Head[i].Adjacent;
while(p!=NULL){
count[p->VerAdj]++;
p=p->Link;
}
}
int top=-1;
for(int i=0;i<n;i++)
if(count[i]==0)
{
count[i]=top;top=i; //入栈
}
for(int i=0;i<n;i++)
{
if(top==-1)
{
cout<<"There is a cycle in network!"<<endl;
}
else
{
int j=top;
top=count[top];
cout<<j<<" ";//出栈
Edge*p=Head[j].Adjacent;
while(p!=NULL)
{
int k=p->VerAdj;
if(--count[k]==0)
{
count[k]=top;top=k;
}
p=p->Link;
}
}
}
delete []count;
}
/*
void critical_path()
{
int ve[n];
for(int i=0;i<n;i++)
{
ve[i]=0;
}
for(int i=0;i<n-1;i++)
{
p=Head[i]->adjacent(Head[i]);
while(p!=NULL)
{
k=p->VerAdj;
if(ve[i]+p->cost>ve[k])
ve[k]=ve[i]+p->cost;
p=p->Link;
}
}
for(int i=0;i<n;i++)
{
vl[i]=ve[n];
}
for(i=n-1;i>0;i++)
{
p=Head[i].adjacent;
while(p!=NULL)
{
k=p->VerAdj;
if(vl[k]-p->cost<v[i])
{
vl[i]=vl[k]-p->cost;
}
p=p->Link;
}
}
for(int i=0;i<n;i++)
{
p=Head[i]->adjacent;
while(p!=NULL)
{
k=p->VerAdj;
e=ve[i];
l=vl[k]-p->cost;
}
if(l=e)
printf("<%d,%d> is Critical Activity!");
p=p->Link;
}
}
*/
void GraphList::Output(){
cout<<"当前图如下："<<endl;
int A[e];
for(int i=0;i<GraphSize;i++)
{
cout<<"H["<<i<<"]->";
Vertex H=Head[i];
int n=GetNeighbors(i,A);
for(int j=0;j<n;j++)
{
cout<<A[j]<<"->";
}
cout<<"\n";
}
}
1 #include <iostream>
2 #include <memory.h>
3 using namespace std;
4
5 const int MaxWeight=1000;
6
7 class Graph_Matrix
8 {
9 private:
10 int MaxGraphSize;
11 int **Edge;
12 int GraphSize;//顶点数
13 int e;//边数
14 int alllengthflag;
15 int**path;
16 int**A;
17 public:
18 Graph_Matrix(int Max);
19 Graph_Matrix(const Graph_Matrix&A);
20 void Create();
21 virtual~Graph_Matrix();
22
23
24 int IsEmpty() const{return !GraphSize;};
25 int GraphFull()const{return GraphSize==MaxGraphSize;}
26 int NumberOfVertices()const{return GraphSize;}
27 int NumberOfEdges()const;//返回图的边的个数
28 int GetWeight(const int &v1,const int&v2);//返回指定边的权值
29 void GetNeighbors(const int &v,int A[]);//返回顶点v的邻接顶点表
30
31 //void InsertVertex(const int &v);//向图中插入一个顶点
32 bool InsertEdge(const int &v1,const int &v2,int weight);//向图中插入一条边
33 bool SetEdge(const int &v1,const int &v2,int weight);
34
35 bool DeleteVertex(const int &v);//在图中删除一个顶点
36 bool DeleteEdge(const int &v1,const int &v2);//在图中删除一条边
37
38 int GetDiameter();
39 //void DepthFirstSearch();//采用递归的方法从顶点表的第一个顶点开始进行图的深度优先搜索
40 //void DFS(const int v);//从顶点V开始进行图的深度优先搜索
41 //void BFS(const int v);//从顶点V开始进行图的广度优先搜索
42
43 bool TopoOrder();//检测是否有环，如果无环输出图的拓扑序列
44
45 //void CriticalPath();//输出图的关键路径
46
47 //void ShortestPath(const int v);//在非权图中求指定顶点到其他所有顶点的最短路径
48 //void DShortestPath(const int v);//在正权图中求指定定点到其他所有定点的最短路径
49
50 void AllLength();//在正权图中求每对顶点间的最短路径
51
52 bool IsFreeTree(); //检测是否为自由树
53
54
55
56 //void Prim();//构造图的最小支撑树的普里姆算法
57 //void Output();//用来测试
58 };
59
60 Graph_Matrix::Graph_Matrix(int Max=100):MaxGraphSize(Max),alllengthflag(0)
61 {
62 cout<<"开始"<<endl;
63 Edge=new int*[Max];
64 for(int i=0;i<Max;i++)
65 Edge[i]=new int[Max];
66 for(int i=0;i<Max;i++)
67 for(int j=0;j<Max;j++)
68 Edge[i][j]=MaxWeight;
69 Create();
70 }
71
72
73 void Graph_Matrix::Create()
74 {
75 int from,to,weight;
76 int E;
77 int i=0;
78 cout<<"请输入顶点和边的个数"<<endl;
79 cin>>GraphSize>>E;
80 while(i<E)
81 {
82 cout<<"请输入第"<<++i<<"条边的始点 终点 权"<<endl;
83 cin>>from>>to>>weight;
84 InsertEdge(from,to,weight);
85 }
86 cout<<"创建成功！"<<endl;
87 }
88
89
90 Graph_Matrix::Graph_Matrix(const Graph_Matrix&A)
91 {
92 e=A.e;
93 GraphSize=A.GraphSize;
94 MaxGraphSize=A.MaxGraphSize;
95 Edge=new int*[MaxGraphSize];
96 for(int i=0;i<MaxGraphSize;i++)
97 Edge[i]=new int[MaxGraphSize];
98 for(int i=0;i<MaxGraphSize;i++)
99 for(int j=0;j<MaxGraphSize;j++)
100 Edge[i][j]=A.Edge[i][j];
101
102 }
103
104
105 bool Graph_Matrix::IsFreeTree()
106 {
107 Graph_Matrix A(*this);//建立自己的副本
108 //计算每个结点的入度
109 int count[A.GraphSize];
110 memset(count,0,sizeof(count));
111 for(int j=0;j<A.GraphSize;j++)//列
112 {
113 for(int i=0;i<A.GraphSize;i++) //行
114 {
115 if(A.Edge[i][j]!=MaxWeight) count[j]++;
116 }
117 cout<<"count["<<j<<"]="<<count[j]<<endl;
118 }
119
120 int temp=0; //计算度为0的点的个数
121
122 int top=-1;//初始化栈顶指针
123 for(int i=0;i<A.GraphSize;i++)
124 {
125 if(count[i]==0)//将入度为0的点入栈
126 {
127 count[i]=top;
128 top=i;
129 temp++;
130 }
131 }
132
133 if(temp!=1) return 0;/*如果有多个度为0的点，则不可能为自由树*/
134
135
136 for(int i=0;i<A.GraphSize;i++)
137 {
138 //cout<<"top="<<top<<endl;
139
140 /*循环群体还未被执行GraphSize次，已经没有入度为0的点，说明有回路*/
141 if(top==-1)
142 {
143 //cout<<"有回路"<<endl;
144 return 0;
145 }
146 else
147 {
148 int j=top;top=count[top];/*从栈中弹出一个顶点 j*/
149 cout<<j<<" ";
150
151 /*删除与j相关的边并更新count*/
152 for(int p=0;p<A.GraphSize;p++)
153 {
154 if(A.Edge[j][p]!=MaxWeight)
155 {
156 A.Edge[j][p]=MaxWeight;
157 count[p]--;
158 A.e--;
159 }
160 }
161 //for(int p=0;p<A.GraphSize;p++)
162 // cout<<"count["<<p<<"]="<<count[p]<<endl;
163
164 for(int p=0;p<A.GraphSize;p++)
165 {
166 if(count[p]==0)/*将入度为0的点入栈*/
167 {
168 count[p]=top;
169 top=p;
170 }
171 }
172
173 }
174 }
175 return 1;
176 }
177
178
179 void Graph_Matrix::AllLength() //在正权图中求每对顶点间的最短路径
180 {
181 alllengthflag=1; //方便析构函数处理，如调用此函数才析构相关数组
182
183 /*初始化*/
184 int n=GraphSize;
185 path=new int*[n]; //path记录最短路径终点前一个结点
186 A=new int*[n]; //A记录最短路径
187 for(int i=0;i<n;i++)
188 {
189 path[i]=new int[n];
190 A[i]=new int[n];
191 }
192 for(int i=0;i<n;i++)
193 {
194 for(int j=0;j<n;j++)
195 {
196 A[i][j]=Edge[i][j];
197 if(i!=j&&A[i][j]<MaxWeight)
198 {
199 path[i][j]=i;
200 }
201 else
202 {
203 path[i][j]=-1;
204 }
205 }
206 }
207
208
209 for(int k=0;k<n;k++)//加入k作为中间结点
210 {
211 for(int i=0;i<n;i++)
212 {
213 if(i!=k)
214 {
215 for(int j=0;j<n;j++)
216 {
217 if(j!=k/*以k作为终点*/&&j!=i/*到自己*/&&A[i][j]!=MaxWeight&&A[i][k]+A[k][j]<A[i][j])
218 {
219 //更新
220 A[i][j]=A[i][k]+A[k][j];
221 path[i][j]=path[k][j];
222 }
223 }
224 }
225 }
226 }
227
228 cout<<"最短路径最后经过的点为："<<endl;
229 printf(" ");
230 for(int j=0;j<n;j++)
231 printf("% 5d ",j);
232 cout<<endl;
233 for(int i=0;i<n;i++)
234 {
235 printf("% 5d ",i);
236 for(int j=0;j<n;j++)
237 {
238 printf("% 5d ",path[i][j]);
239 }
240 cout<<endl;
241 }
242 cout<<"每对顶点最短路径长度为："<<endl;
243 printf(" ");
244 for(int j=0;j<n;j++)
245 printf("% 5d ",j);
246 printf("\n");
247 for(int i=0;i<n;i++)
248 {
249 printf("% 5d ",i);
250 for(int j=0;j<n;j++)
251 {
252 printf("% 5d ",A[i][j]);
253 }
254 cout<<endl;
255 }
256 }
257
258
259 int Graph_Matrix::GetDiameter()
260 {
261 if(IsFreeTree()==0)
262 {
263 cout<<"不是有向树"<<endl;
264 return -1;
265 }
266
267 AllLength();
268
269 int d=0;
270 for(int i=0;i<GraphSize;i++)
271 {
272 for(int j=0;j<GraphSize;j++)
273 {
274 if(A[i][j]>d&&A[i][j]!=MaxWeight) d=A[i][j];
275 }
276 }
277 cout<<"直径是"<<d<<endl;
278 return d;
279 }
280
281 int Graph_Matrix::GetWeight(const int &v1,const int&v2){
282 if(v1==-1||v2==-1||v1>=GraphSize||v2>=GraphSize) return 0;
283
284 return Edge[v1][v2];
285 }
286
287 bool Graph_Matrix::DeleteEdge(const int&v1,const int &v2)//删除指定边
288 {
289 if(v1==-1||v2==-1||v1>=GraphSize||v2>=GraphSize) return 0;
290 if(Edge[v1][v2]==MaxWeight) return 0;
291 Edge[v1][v2]==MaxWeight;
292 e--;
293 return 1;
294 }
295
296 bool Graph_Matrix::InsertEdge(const int &v1,const int &v2,int weight)//向图中插入一条边
297 {
298 if(v1==-1||v2==-1||v1>=GraphSize||v2>=GraphSize) return 0;
299 if(v1==v2) return 0;
300 if(Edge[v1][v2]!=MaxWeight) return 0;
301 Edge[v1][v2]=weight;
302 e++;
303 return 1;
304 }
305
306 bool Graph_Matrix::SetEdge(const int &v1,const int &v2,int weight)//修改指定边的权值
307 {
308 if(v1==v2) return 0;
309 if(v1==-1||v2==-1||v1>=GraphSize||v2>=GraphSize) return 0;
310 if( InsertEdge(v1,v1,weight)==0) //插入不成功则该边已存在
311 Edge[v1][v2]=weight;
312 return 1;
313 }
314
315 bool Graph_Matrix::DeleteVertex(const int &v)//删除顶点
316 {
317 if(v==-1||v>=GraphSize) return 0;
318 for(int i=0;i<GraphSize;i++)
319 {
320 if(Edge[i][v]!=MaxGraphSize)
321 {
322 Edge[i][v]=MaxGraphSize;
323 e--;
324 }
325 }
326
327 for(int i=0;i<GraphSize;i++)
328 {
329 if(Edge[v][i]!=MaxGraphSize)
330 {
331 Edge[v][i]=MaxGraphSize;
332 e--;
333 }
334 }
335
336 }
337
338
339
340
341
342 /*
343 void Graph_Matrix::Output()
344 {
345 for(int i=0;i<GraphSize;i++)
346 {
347 for(int j=0;j<GraphSize ;j++)
348 {
349 printf("% 5d ",Edge[i][j]);
350 }
351 cout<<endl;
352 }
353
354 }//测试函数
355 */
356
357 bool Graph_Matrix::TopoOrder()
358 { Graph_Matrix A(*this);//建立自己的副本
359 //计算每个结点的入度
360 int count[A.GraphSize];
361 memset(count,0,sizeof(count));
362 for(int j=0;j<A.GraphSize;j++)//列
363 {
364 for(int i=0;i<A.GraphSize;i++) //行
365 {
366 if(A.Edge[i][j]!=MaxWeight) count[j]++;
367 }
368 //cout<<"count["<<j<<"]="<<count[j]<<endl;
369 }
370
371 int top=-1;//初始化栈顶指针
372 for(int i=0;i<A.GraphSize;i++)
373 {
374 if(count[i]==0)//将入度为0的点入栈
375 {
376 count[i]=top;
377 top=i;
378 }
379 }
380
381 cout<<"拓扑序列为：";
382
383
384 for(int i=0;i<A.GraphSize;i++)
385 {
386 //cout<<"top="<<top<<endl;
387 //循环群体还未被执行GraphSize次，已经没有入度为0的点，说明有回路
388 if(top==-1)
389 {
390 cout<<"有回路"<<endl;
391 return 0;
392 }
393 else
394 {
395 int j=top;top=count[top];//从栈中弹出一个顶点 j
396 cout<<j<<" ";
397 //删除与j相关的边并更新count
398
399 for(int p=0;p<A.GraphSize;p++)
400 {
401 if(A.Edge[j][p]!=MaxWeight)
402 {
403 A.Edge[j][p]=MaxWeight;
404 count[p]--;
405 A.e--;
406 }
407 }
408 //for(int p=0;p<A.GraphSize;p++)
409 // cout<<"count["<<p<<"]="<<count[p]<<endl;
410
411 for(int p=0;p<A.GraphSize;p++)
412 {
413 if(count[p]==0)//将入度为0的点入栈
414 {
415 count[p]=top;
416 top=p;
417 }
418 }
419
420 }
421 }
422 }
423 Graph_Matrix::~Graph_Matrix()
424 {
425 for(int i=0;i<GraphSize;i++)
426 delete[]Edge[i];
427 delete[]Edge;
428
429 if(alllengthflag==1)
430 {
431 for(int i=0;i<GraphSize;i++)
432 delete[]A[i];
433 delete[]A;
434 for(int i=0;i<GraphSize;i++)
435 delete[]path[i];
436 delete[]path;
437 }
438 }
439
440 int main() {
441 Graph_Matrix A(100);
442 //A.Output();
443
444 //A.TopoOrder();
445 A.GetDiameter();
446 return 0;
447 }
