图的邻接矩阵和邻接表表示

最新推荐文章于 2022-09-21 20:07:22 发布
最新推荐文章于 2022-09-21 20:07:22 发布
阅读量400 收藏 1
点赞数 1
分类专栏： 算法和数据结构 文章标签： c++ 网络图 继承
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/bbtking/article/details/111500943
版权

该图扩展到网络的功能，有最短路径和拓扑排序，关键路径功能，其中图分四种类型，存储方式为两种。
以下为运行结果
在这里插入图片描述
基类：
头文件Graph.h

#ifndef _Graph_h_
#define _Graph_h_




class GRAPH
{
	public:
		GRAPH();//构造 
		~GRAPH();//析构 
		
		int ReturnVert();//返回点的个数 
		int ReturnEdge();//返回边的条数 
		
		virtual void CreateMGraph()=0;//创建 
		virtual void DestoryGraph()=0;//销毁 
		virtual void PutoutGraph() const =0;//输出 
		
		virtual int LocateVertex( char v)=0;//返回顶点的下标 
		virtual char GetVertex( int i)=0;//返回下标为i的点的值 
		virtual string FirstAdjVertex( char v)=0;//v的第一个邻接点 
		virtual string NextAdjVertex( char v, char w)=0;//v的w后面的邻接点 
		virtual void InsertVertex( char v)=0;//插入点 
		virtual void DeleteVertex( char v)=0;//删除点以及相关边 
		virtual void DeleteEdges( char v, char w)=0;//删除边 
		virtual void InsertVertex( char v, char w)=0;//插入两点间的边 
		
		virtual void DFS( int i,bool vis[])=0;//从第i个点遍历,vis[]为标记数组 
		virtual int DFSTrave()=0;//遍历块的个数	
		
		virtual void Floyd(int t, int t1)=0;//两点最短路径 
		virtual void FloydPrintPath(int u,int v,int **path)=0;//输出路径过程 
		
		virtual int TopologicalSort()=0;//拓扑排序 
		virtual void CriticalPath()=0;//关键路径 
	
	protected:
		int numNodes,numEdges;//图的点，边 
		int kind;//种类 
};
#endif

Graph.cpp

#include <iostream>
using namespace std;
#include"Graph.h"

GRAPH::GRAPH(): kind(0),numNodes(0),numEdges(0)
{
}
GRAPH::~GRAPH()
{
}
int GRAPH::ReturnVert()
{
	return numNodes;
}
int GRAPH::ReturnEdge()
{
	return numEdges;
}

子类矩阵存储：
头文件MGraph.h

#ifndef _MGraph_h_
#define _MGraph_h_
#include "Graph.h"




class MGRAPH: virtual public GRAPH
{
	public:
		 MGRAPH();//构造 
		 ~MGRAPH();//析构
		 
		void CreateMGraph();//创建 
		void DestoryGraph();//销毁 
		void PutoutGraph() const;//输出 
		
		
		int LocateVertex( char v);//返回点的下标 
		char GetVertex( int i);//返回下标为i的点的值 
		string FirstAdjVertex( char v);//v的第一个邻接点 
		string NextAdjVertex( char v, char w);//v的w后面的邻接点 
		void InsertVertex( char v);//插入点 
		void DeleteVertex( char v);//删除点以及相关边 
		void DeleteEdges( char v, char w);//删除边 
		void InsertVertex( char v, char w);//插入两点间的边 
		
		void DFS( int i,bool vis[]);//从第i个点遍历 
		int DFSTrave();//遍历块的个数	
		
		void Floyd(int t, int t1);//两点最短路径 
		void FloydPrintPath(int u,int v,int **path);//输出路径过程 
		
		int TopologicalSort();//拓扑排序 
		void CriticalPath();//关键路径 
		
	protected:
		char *vexs; //存顶点的值 
		int **arc;//邻接矩阵
		int *in; //每个顶点入度的值 
};
#endif

MGraph.cpp

#include <iostream>
#include <cstring>
#include <stdlib.h>
#include <string>
using namespace std;
#include "MGraph.h"

MGRAPH::MGRAPH()
{
	int i,j;
	for(i=0;i<numNodes;++i)
	{
		vexs = new  char[numNodes];
		vexs[i]='a'+i;
		for(j=0;j<numNodes;++j)
		{
			arc[i][j]=0;
		}
	}
}
MGRAPH::~MGRAPH()
{
	delete vexs;
	for(int i=0;i<numNodes;++i)
	{
		delete arc[i];
	}
}
void MGRAPH::CreateMGraph()
{
	int i,j,k,w,numnode;
	char e;
	cout <<"输入图的种类(1-无向无权，2-有向无权，3-无向有权, 4-有向有权): ";
	cin >>kind;
	cout<<"输入顶点数: ";
	cin>>numNodes;
	numnode=numNodes+11;
	cout<<"输入边数: ";
	cin >>numEdges;//算边可能点不在范围内及自己连自己？
	vexs = new  char[numnode];
	in = new int[numnode];
	 arc = new int*[numnode];
	for(i = 0;i <numnode;i++)
	{
		arc[i]=new int[numnode];
	}
	for(i = 0;i <numnode;i++)//用此
		for(j = 0;j <numnode;j++)
		{ 
			arc[i][j]=0;	// 邻接矩阵初始化
			in[i]=0; 
		} 
	for(i = 0;i <numNodes;i++) // 读入顶点信息,建立顶点表 
	{
		cout<<"输入顶点：(点的下标为"<<i<<")\n";
		cin >> vexs[i];
	}
	for(k = 0;k <numEdges;k++) // 读入numEdges条边 
	{
		if(kind==1||kind==2)
		{
			cout<<"输入边的两点下标(如果有向注意顺序): ";
			scanf("%d %d",&i,&j);
			arc[i][j]=1;
			in[j]++;
			if(kind==1)
			{ 
				arc[j][i]=1;
				in[i]++;
			} 
	}
		else
		{
			cout<<"输入边的两点下标(如果有向注意顺序)及权: ";
			cin >> i >> j >> w;
			arc[i][j]=w;
			in[j]++;
			if(kind==3)
			{
				arc[j][i]=w;
				in[i]++;
			}
		}
	}
}
void MGRAPH::PutoutGraph() const
{
	int i,j;
	cout<<"  ";
	for(i=0;i<numNodes;++i)
	{
		cout<<vexs[i]<<' ';
	}
	cout<<endl;
	for(i=0;i<numNodes;++i)
	{
		cout<<vexs[i]<<' ';
		for(j=0;j<numNodes;++j)
		{
			cout<<arc[i][j]<<' ';
		}
		cout<<'\n';
	}
//	for(int i=0;i<numNodes;++i)
//	{
//		cout<<vexs[i]<<"的度: "<<in[i]<<endl; 
//	} 
	cout<<"图的种类: ";
	if(kind==1)
	{
		cout<<"无权无向图\n";
	}
	else if(kind==2)
	{
		cout<<"无权有向图\n";
	}
	else if(kind==3)
	{
		cout<<"有权无向图\n";
	}
	else
	{
		cout<<"有权有向图\n";
	}
	cout<<"边的条数: "<<numEdges<<endl;
	cout<<"点的个数: "<<numNodes<<endl;

}
void MGRAPH::DestoryGraph()
{
	int i,j;
	for(i = 0;i <numNodes+11;i++)
			delete	arc[i];
	delete vexs;
	delete in;
	numEdges=0;
	numNodes=0;
} 
int MGRAPH::LocateVertex( char v)
{
	int i=-1,k,ok=1;
	for(k=0;k<numNodes&&ok;++k)
	{
		if(vexs[k]==v)
		{
			i=k;
			ok=0;
		}
	}
	return i;
}
char MGRAPH::GetVertex( int i)
{
	return i > numNodes ? 0 :vexs[i-1];
}
string MGRAPH::FirstAdjVertex( char v)
{
	int i=LocateVertex(v),ok=1;
	string c;
	for(int j=0;j<numNodes&&ok;++j)
	{
		if(arc[i][j]!=0)
		{
			c=vexs[j];
			ok=0;
		}
	}
	return ok==0 ? c : "该点无邻接点";
}
string MGRAPH::NextAdjVertex(char v, char w)
{
	int i=LocateVertex(v),ok=1,okk=0;
	string c;
	for(int j=0;j<numNodes&&ok;++j)
	{
		if(okk&&arc[i][j]!=0)
		{
			c=vexs[j];
			ok=0;
		}
		if(!okk&&arc[i][j]!=0&&vexs[j]==w)
		{
			okk=1;
		}
	}
	return ok==0 ? c : "该点无邻接点";
}
void MGRAPH::InsertVertex( char v)
{
	vexs[numNodes]=v;
	numNodes++;
}
void MGRAPH::DeleteVertex( char v)
{
	int i, j=LocateVertex(v),k;
	for(i=0;i<numNodes;++i)
	{
		if(arc[j][i]!=0)
		{
			numEdges--;
		}
		if(kind==2||kind==4)
		{
			if(arc[i][j]!=0)//有向图要减两次
			{
				numEdges--;
			}
		}
		arc[j][i]=0;
		if(kind==1||kind==3)
		arc[i][j]=0;
	}
	for(k=j;k<numNodes;++k)//边也要重新，每层更新干净
	{
		for(i=0;i<numNodes;++i)
		{
			arc[k][i]=arc[k+1][i];
		}
	}
	for(k=j;k<numNodes;++k)
	{
		for(i=0;i<numNodes-1;++i)
		{
			arc[i][k]=arc[i][k+1];
		}
	}
	for(i=j;i<numNodes-1;++i)
	{
		vexs[i]=vexs[i+1];
	}
	numNodes--;
}
void MGRAPH::DeleteEdges(char v, char w)
{
	int i=LocateVertex(v),j=LocateVertex(w);
	if( i < 0 || j < 0 || i == j )//i,j不符时
		return;
	arc[i][j]=0;
	if(kind==1||kind==3)
	arc[j][i]=0;
	numEdges--;
}
void MGRAPH::InsertVertex( char v, char w)
{
	int a;
    int i=LocateVertex(v),j=LocateVertex(w);
    if(i==j)
    return ;
    if(arc[i][j]!=0)
    {
    	numEdges--;
	}
    if(kind==3||kind==4)
    {
    	cout<<"输入该边的权: ";
    	cin >> a;
    	arc[i][j]=a;
    	if(kind==3)
    	{
    		arc[j][i]=a;
		}
	}
	else
	{
	    arc[i][j]=1;
	    if(kind==1)
	    arc[j][i]=1;
	}
    numEdges++;
}

void MGRAPH::DFS(int i,bool vis[])
{
	int j;
	vis[i]=true;
	cout<<vexs[i]<< " ";
	for(j=0;j<numNodes;++j)
	{
		if(arc[i][j]!=0&&!vis[j])
		{
			DFS(j,vis);
		}
	}
}
int MGRAPH::DFSTrave()
{
	int i,s=0;
	bool vis[numNodes];
	memset(vis,false,sizeof(vis));
	for(i=0;i<numNodes;++i)
	{
		if(!vis[i])
		{
			DFS(i,vis);
			++s;//块的个数
		}
	}
	return s;
}
void MGRAPH::Floyd(int t, int t1)//t到t1的最短路径
{
	int i,j,u;
	int a[100][100];
	int **path;
	path = new int*[numNodes];
	for(i=0;i<numNodes;++i)
	{
		path[i] = new int[numNodes];
	} 
	for(i=0;i<numNodes;++i)
	{
		for(j=0;j<numNodes;++j)
		{
			if(arc[i][j]==0)
			arc[i][j]=999999;//此999999设为max 
		}
	}
	for(i=0;i<numNodes;++i)
	{
		for(j=0;j<numNodes;++j)
		{
			a[i][j]=arc[i][j];
			path[i][j]=-1;
		}
	}
	for(u=0;u<numNodes;++u)
	{
		for(i=0;i<numNodes;++i)
		{
			for(j=0;j<numNodes;++j)
			{
				if(a[i][j]>a[i][u]+a[u][j])
				{
					a[i][j]=a[i][u]+a[u][j];
					path[i][j]=u;
				}
			}
		}
	}
	if(a[t][t1]==999999)
	{
		cout<<"无路径"; 
	}
	else
	cout<<"最短路径: "<< a[t][t1]<<endl;
	FloydPrintPath(t,t1,path);
	for(i=0;i<numNodes;++i)
	{
		delete path[i];
	} 
}
void MGRAPH::FloydPrintPath(int u,int v,int **path)//输出u到v最短路径路线 
{
	if(path[u][v]==-1)
	{
		cout<<vexs[u]<<"->"<<vexs[v]<<' ';
	}
	else
	{
		int mid  = path[u][v];
		FloydPrintPath(u,mid,path);
		FloydPrintPath(mid,v,path);
	}
}
int MGRAPH::TopologicalSort()//拓扑排序 
{
	int i, k, count = 0,gettop,top = 0,top2;
	int stack[numNodes]; // 用于存储入度为0的顶点
	int etv[numNodes],stack2[numNodes]; 
	for( i=0; i < numNodes; i++ )
	{
		if( 0 == in[i] )
		{
			stack[++top] = i; // 将度为0的顶点下标入栈
		}
	}
	top2 = 0;
	for( i=0; i < numNodes; i++ )
	{
		etv[i] = 0;
	}
	
	while( 0 != top )
	{
		gettop = stack[top--]; // 出栈
		stack2[++top2] = gettop; // 保存拓扑序列顺序
		count++;
		
		for(int j=0;j<numNodes;++j)
		{
			if(arc[gettop][j]!=0)
			{
			    if( !(--in[j]) )
			    {
					stack[++top] = j;
			    }
			
			  	if( (etv[gettop]+arc[gettop][j]) > etv[j] )
			  	{
			    	etv[j] = etv[gettop] +arc[gettop][j];
			  	}
			}
		}
	}
	if( count < numNodes ) //存在环
	{
		return -1;
	}
	else
	{
		return 0;
	}
	
} 
void MGRAPH::CriticalPath()//关键路径 
{
	int i, gettop, k, j,m=0,ete, lte;
	int etv[numNodes],stack2[numNodes],top2,ltv[numNodes]; 
	int  count = 0,top = 0;
	int stack[numNodes]; // 用于存储入度为0的顶点
	
	for( i=0; i < numNodes; i++ )
	{
		if( 0 == in[i] )
		{
			stack[++top] = i; // 将度为0的顶点下标入栈
		}
	}
	top2 = 0;

	for( i=0; i < numNodes; i++ )
	{
		etv[i] = 0;
	}
	
	while( 0 != top )
	{
		gettop = stack[top--]; // 出栈
		stack2[++top2] = gettop; // 保存拓扑序列顺序
		count++;
		
		for(int j=0;j<numNodes;++j)
		{
			if(arc[gettop][j]!=0)
			{
			    if( !(--in[j]) )
			    {
					stack[++top] = j;
			    }
			
			  	if( (etv[gettop]+arc[gettop][j]) > etv[j] )
			  	{
			    	etv[j] = etv[gettop] +arc[gettop][j];
			  	}
			}
		}
	}
	if( count < numNodes ) //存在环或无向图 
	{
		cout<<"无关键路径\n";
	}
	else
	{
		for( i=0; i < numNodes; i++ )
		{
			ltv[i] =etv[numNodes-1];
		}
		while( 0 != top2 )
		{
			gettop = stack2[top2--];
			for(int j=0;j<numNodes;++j) 
			{
				if(arc[gettop][j]!=0)
				{
					if( (ltv[j] - arc[gettop][j]) < ltv[gettop] )
					{
						ltv[gettop] = ltv[j] - arc[gettop][j];
					}
				}
			}
		}
		
		for( j=0; j < numNodes; j++ )
		{
			for(int k=0; k < numNodes;++k)
			{
				if(arc[j][k]!=0)
				{
					ete = etv[j];
					lte = ltv[k] - arc[j][k];
					if( ete == lte )
					{
						cout<<vexs[j]<<"->"<<vexs[k]<<" length: "<< arc[j][k]<<" "<<endl;
						m++;
					}
				}
			}
		}
		if(!m)
		{
			cout<<"无关键路径\n";
		}

	}
	
	
	
}

子类邻接表存储
AGraph.h

#ifndef _AGraph_h_
#define _AGraph_h_
#include "Graph.h"

struct EdgeNode //* 边表结点
{ 
	int adjvex;    //* 邻接点域,存储该顶点对应的下标
	int info;		//* 用于存储权值,对于非网图可以不需要
	struct EdgeNode *next; //* 链域,指向下一个邻接点
};

 struct VertexNode //* 顶点表结点
{
	int in;//点的入度 
	char data; //* 顶点域,存储顶点信息
	EdgeNode *firstedge;//* 边表头指针
};
class AGRAPH: virtual public GRAPH
{
	public:
		AGRAPH();//构造 
		~AGRAPH();//析构
		 
		void CreateMGraph();//创建 
		void DestoryGraph();//销毁 
		void PutoutGraph() const;//输出 
		
		
		int LocateVertex( char v);//返回点的下标 
		char GetVertex( int i);//返回下标为i的点的值 
		string FirstAdjVertex( char v);//v的第一个邻接点 
		string NextAdjVertex( char v, char w);//v的w后面的邻接点 
		void InsertVertex( char v);//插入点 
		void DeleteVertex( char v);//删除点以及相关边 
		void DeleteEdges( char v, char w);//删除边 
		void InsertVertex( char v, char w);//插入两点间的边 
		
		void DFS( int i,bool vis[]);//从第i个点遍历 
		int DFSTrave();//遍历块的个数	
		
		void Floyd(int t, int t1);//两点最短路径 
		void FloydPrintPath(int u,int v,int **path);//输出路径过程 
		
		int TopologicalSort();//拓扑排序 
		void CriticalPath();//关键路径 
		 
	protected:
		VertexNode *vexs;
};
#endif

AGraph.cpp

#include <iostream>
#include <cstring>
#include <string>
#include <stdlib.h>
using namespace std;
#include "AGraph.h"

AGRAPH::AGRAPH()
{
	vexs = new VertexNode[numNodes];
	for (int i = 0; i <numNodes; i++)
    {
        vexs[i].data = 'a'+i;
        vexs[i].firstedge = NULL;
    }
}
AGRAPH:: ~AGRAPH()
{
	delete vexs;
}
void AGRAPH::CreateMGraph()
{
	int i,j,k,w;
	EdgeNode *e;
	cout<<"输入图的类型(1-无向无权，2-有向无权，3-无向有权, 4-有向有权):";
	cin>>kind;
	printf("输入顶点数和边数:\n");
	scanf("%d %d",&numNodes,&numEdges); // 输入顶点数和边数
	vexs = new VertexNode[numNodes+11];
	for(i = 0;i < numNodes;i++) //读入顶点
	{
		cout<<"输入点: ";
	 	cin>>vexs[i].data;// 输入顶点信息
		vexs[i].firstedge=NULL; 	//将边表置为空表
		vexs[i].in=0;
	}
	for(k = 0;k < numEdges;k++)// 建立边表
	{
		printf("输入边上的顶点序号:\n");
		scanf("%d %d",&i,&j); // 输入边(vi,vj)上的顶点序号 
		e = new EdgeNode; // 向内存申请空间,生成边表结点
		if(kind>2)
		{
			cout<<"输入权: ";
			cin>>w;
			e->info=w;
		}
		else
		{
			e->info=0;
		}
		e->adjvex=j;
		vexs[j].in++;
		e->next=vexs[i].firstedge;	// 将e的指针指向当前顶点上指向的结点
		vexs[i].firstedge=e;// 将当前顶点的指针指向e
		
		
		if(kind==1||kind==3)
		{
			e=new EdgeNode; //向内存申请空间,生成边表结点
			if(kind>2)
			{
				e->info=w;
			}
			else
			{
				e->info=0;
			}
			e->adjvex=i;					
			vexs[i].in++;
			e->next=vexs[j].firstedge;	
			vexs[j].firstedge=e;
		}
	}
}
void AGRAPH::PutoutGraph() const
{
	int i,j;
	EdgeNode *p;
	for(i=0;i<numNodes;++i)
	{
		j=0;
		p=vexs[i].firstedge;
		cout<<vexs[i].data<<' ';
		while(p!=NULL)
		{
			{
				cout<<vexs[i].data<<"->"<<vexs[p->adjvex].data<<" "; 
				if(kind>2)
				cout<<": "<<p->info<<' ';
			}
			p=p->next;
		}
		cout<<'\n';
	}
//	for(int i=0;i<numNodes;++i)
//	{
//		cout<<vexs[i].data<<"的度: "<<vexs[i].in<<endl; 
//	} 
	cout<<"图的种类: ";
	if(kind==1)
	{
		cout<<"无权无向图\n";
	}
	else if(kind==2)
	{
		cout<<"无权有向图\n";
	}
	else if(kind==3)
	{
		cout<<"有权无向图\n";
	}
	else
	{
		cout<<"有权有向图\n";
	}
	cout<<"点的个数: "<<numNodes<<endl;
	cout<<"边的条数: "<<numEdges<<endl;
}
void AGRAPH::DestoryGraph()
{
	int i;
	EdgeNode *p, *q;
	for(i = 0;i <numNodes;i++)
	{
		p = vexs[i].firstedge;
		while(p)
		{
			q=p->next;
			if(kind==3||kind==4)
			{
				p->info=0;
			}
			delete p;
			p=q;
		}
	}
	numEdges=0;
	numNodes=0;
}
int AGRAPH::LocateVertex(char v)
{
	int i=-1,k,ok=1;
	for(k=0;k<numNodes&&ok;++k)
	{
		if(vexs[k].data==v)
		{
			i=k;
			ok=0;
		}
	}
	return i;
}
char AGRAPH::GetVertex(int i)
{
	return i > numNodes || i<=0 ? 0 : vexs[i-1].data;
}
string AGRAPH::FirstAdjVertex(char v)
{
	EdgeNode *p;
	string c;
	int i=LocateVertex(v);
	p = vexs[i].firstedge;
	if(p)
	{
		c= vexs[p->adjvex].data;
	}
	else
	{
		c= "该点无邻接点";
	}
	return c;
}
string AGRAPH::NextAdjVertex( char v, char w)
{
	EdgeNode *p;
	string c;
	int i=LocateVertex(v),j=LocateVertex(w);
	p = vexs[i].firstedge;
	while(p && p->adjvex != j)
	{
		p=p->next;
	}
	if(!p || !p->next)
	{
		c= "该点无邻接点";
	}
	else
	{
		p=p->next;
		c= vexs[p->adjvex].data;
	}
	return c;
}
void AGRAPH::InsertVertex(char v)
{
	vexs[numNodes].data=v;
	vexs[numNodes].firstedge=NULL;
	numNodes++;
}
void AGRAPH::DeleteVertex( char v)
{
	int i, j=LocateVertex(v),k;
	EdgeNode *p, *q;//q记录新的 
	p=vexs[j].firstedge;
	cout<<"ss\n";
	while(p)
	{
		//q=p;
//		if(kind>2)
//		{
//			p->info=0;
//		} 
		delete p;
		p=p->next;
//		numEdges--;
	}
	for(i=j;i<numNodes-1;++i)
	{
		vexs[i] =vexs[i+1];
	}
	for(i=0;i<numNodes-1;++i)
	{
		p=vexs[i].firstedge;
		while(p)
		{
			if(p->adjvex == j)
			{
				if(p==vexs[i].firstedge)//如果要删除的是第一个结点 
				{
					vexs[i].firstedge=p->next;
					if(kind>2)
					{
						p->info=0;	
					}
					delete p;
					p=vexs[i].firstedge;
				} 
				else
				{
					q->next=p->next;
					if(kind>2)
					{
						p->info=0;	
					}
					delete p;
					p=p->next;
				}
				if(kind==2||kind==4)
				numEdges--; 
			}
			else
			{
				if(p->adjvex>j)
				{
					p->adjvex--;
				}
				q=p;
				p=p->next;
			}
		}
	}
	numNodes--;
}
void AGRAPH::DeleteEdges(char v, char w)
{
	EdgeNode *p,*q;
	int i=LocateVertex(v),j=LocateVertex(w);
	if( i < 0 || j < 0 || i == j )//i,j不符时
		return;
	p = vexs[i].firstedge;//p指向v的第一条弧尾
	while(p && p->adjvex!=j)
	{
		q=p;
		p=p->next;
	}
	if(p && p->adjvex == j)
	{
		if( p == vexs[i].firstedge )  
			vexs[i].firstedge = p->next;  
		else
			q->next = p->next;  
		if( kind > 2 )
			p->info=0;     
		delete p;                 
	}
	if(kind==1||kind==3)
	{
		p = vexs[j].firstedge;//p指向v的第一条弧尾
		while(p && p->adjvex!=i)
		{
			q=p;
			p=p->next;
		}
		if(p && p->adjvex == i)
		{
			if( p == vexs[j].firstedge ) 
				vexs[j].firstedge = p->next;  
			else
				q->next = p->next; 
			if( kind > 2 )
				p->info=0;      
			delete p;                   
		}
	}
	numEdges--;
}
void AGRAPH::InsertVertex( char v, char w)
{
	int a;
	EdgeNode *p;
    int i=LocateVertex(v),j=LocateVertex(w);
    if( i < 0 || j < 0 ||i==j )
   		return;
    p = new EdgeNode;
    if(kind==3||kind==4)
    {
    	cout<<"输入该边的权: ";
    	cin >> a;
    	p->info = a;
    }
    p->adjvex = j;
	p->next = vexs[i].firstedge;
	vexs[i].firstedge = p;
	if(kind==3||kind==1)
	{
		p = new EdgeNode;
		p->adjvex = i;
	    if(kind==3)
	    {
	    	p->info=a;
		}
		p->next = vexs[j].firstedge;
		vexs[j].firstedge = p;
	}
    numEdges++;
}
void AGRAPH::DFS( int i,bool vis[])
{
	EdgeNode *p;
	p=vexs[i].firstedge;
	vis[i]=true;
	cout<<vexs[i].data<< " ";
	while(p)
	{
		
		if(!vis[p->adjvex])
		{
			DFS(p->adjvex,vis);
		}
		p=p->next;
	}
}
int AGRAPH::DFSTrave()
{
	int i,s=0;
	bool vis[numNodes]; 
	memset(vis,false,sizeof(vis));
	for(i=0;i<numNodes;++i)
	{
		if(!vis[i])
		{
			DFS(i,vis);
			++s;//块的个数
		}
	}
	return s;
}
void AGRAPH::Floyd(int t, int t1)
{
	int i,j,u;
	int dis[100][100];
	int **path;
	path = new int*[numNodes];
	for(i=0;i<numNodes;++i)
	{
		path[i] = new int[numNodes];
	} 
	for(i=0;i<numNodes;++i)
	{
		for(j=0;j<numNodes;++j)
		{
			if(i==j) dis[i][j]=0;
			else dis[i][j]=999999;
		}
	}
	for(i=0;i<numNodes;++i)
	{
		for(j=0;j<numNodes;++j)
		{
			path[i][j]=-1;
		}
	}
	EdgeNode *p;
	for(i=0;i<numNodes;++i)
	{
		p=vexs[i].firstedge;
		while(p)
		{
			dis[i][p->adjvex]=p->info;
			p=p->next;
		}
	}
	for(u=0;u<numNodes;++u)
	{
		for(i=0;i<numNodes;++i)
		{
			for(j=0;j<numNodes;++j)
			{
				if(dis[i][j]>dis[i][u]+dis[u][j])
				{
					dis[i][j]=dis[i][u]+dis[u][j];
					path[i][j]=u;
				}
			}
		}
	}
	if(dis[t][t1]==999999)
	{
		cout<<"无路径"; 
	}
	else
	cout<<"最短路径: "<< dis[t][t1]<<endl;
	FloydPrintPath(t,t1,path);
	for(i=0;i<numNodes;++i)
	{
		delete path[i];
	} 
}
 void AGRAPH::FloydPrintPath(int u,int v, int **path)
 {
 	if(path[u][v]==-1)
	{
		cout<<vexs[u].data<<"->"<<vexs[v].data<<' ';
	}
	else
	{
		int mid  = path[u][v];
		FloydPrintPath(u,mid,path);
		FloydPrintPath(mid,v,path);
	}
 }
int AGRAPH::TopologicalSort()//拓扑排序 
{
	EdgeNode *e;
	int i, k, gettop;
	int top = 0; // 用于栈指针下标索引
	int count = 0; // 用于统计输出顶点的个数
	int stack[numNodes],etv[numNodes],stack2[numNodes]; // 用于存储入度为0的顶点

	
	for( i=0; i < numNodes; i++ )
	{
		if( 0 == vexs[i].in )
		{
			stack[++top] = i; // 将度为0的顶点下标入栈
		}
	}
	
	int top2 = 0;

	for( i=0; i < numNodes; i++ )
	{
		etv[i] = 0;
	}
	
	while( 0 != top )
	{
		gettop = stack[top--]; // 出栈
		stack2[++top2] = gettop;
		count++;
		
		for( e=vexs[gettop].firstedge; e; e=e->next )
		{
			k = e->adjvex;
			if( !(--vexs[k].in) )
			{
				stack[++top] = k;
			}
	
			if( (etv[gettop]+e->info) > etv[k] )
			{
				etv[k] = etv[gettop] + e->info;
			}
		}
	}
	
	if( count < numNodes ) //存在环
	{
		return -1;
	}
	else
	{
		return 0;
	}
} 

void AGRAPH::CriticalPath()//关键路径 
{
	EdgeNode *e;
	int i, gettop, k, j,top=0,count=0,ete,lte,m=0;
	int etv[numNodes], stack2[numNodes],top2,ltv[numNodes]; 
	int stack[numNodes]; // 用于存储入度为0的顶点
	
	for( i=0; i < numNodes; i++ )
	{
		if( 0 == vexs[i].in )
		{
			stack[++top] = i; // 将度为0的顶点下标入栈
		}
	}
	
	top2 = 0;

	for( i=0; i < numNodes; i++ )
	{
		etv[i] = 0;
	}
	
	while( 0 != top )
	{
		gettop = stack[top--]; // 出栈
		stack2[++top2] = gettop;
		count++;
		
		for( e=vexs[gettop].firstedge; e; e=e->next )
		{
			k = e->adjvex;
			if( !(--vexs[k].in) )
			{
				stack[++top] = k;
			}
	
			if( (etv[gettop]+e->info) > etv[k] )
			{
				etv[k] = etv[gettop] + e->info;
			}
		}
	}
	
	if( count < numNodes ) //存在环或无向图 
	{
		cout<<"无关键路径\n";
	}
	else
	{
		for( i=0; i < numNodes; i++ )
		{
			ltv[i] = etv[numNodes-1];
		}
		while( 0 != top2 )
		{
			gettop = stack2[top2--];
			for( e=vexs[gettop].firstedge; e; e=e->next )
			{
				k = e->adjvex;
				if( (ltv[k] - e->info) < ltv[gettop] )
				{
					ltv[gettop] = ltv[k] - e->info;
				}
			}
		}
		
		for( j=0; j < numNodes; j++ )
		{
			for( e=vexs[j].firstedge; e; e=e->next )
			{
				k = e->adjvex;
				ete = etv[j];
				lte = ltv[k] - e->info;
				
				if( ete == lte )
				{
					cout<<vexs[j].data<<"->"<<vexs[k].data<<" length: "<< e->info<<" "<<endl;
					m++;
				}
			}
		}
		
		if(!m)
		{
			cout<<"无关键路径\n";
		}
	}
}

main.cpp

#include <iostream>
#include <cstring>
#include <string>
using namespace std;
#include "Graph.h"
#include "MGraph.h"
#include "AGraph.h"

int main()
{ 
	int i,j,ok=1,okk=0,n,a,b;
	char c, v, w,t,t1;
	GRAPH *G;
	cout <<"1-矩阵存储 2-邻接表存储: ";
	cin >> n;
	if(n==1)
	{
		G = new MGRAPH;//矩阵 
	}
	else
	{
		G = new AGRAPH;//邻接表 
	}
	do
	{
		cout<<"G-创建 D-销毁 P-输出 I-插入点 E-插入边 B-删除点 S-删除边 L-查点 F-邻接点 N-邻接点2 T-遍历块个数 Z-最短路径 C-关键路径 Q-结束: >";
		cin >> c;
		c=toupper(c);
		if(c=='G')
		{
			G->CreateMGraph();
			okk=1;
		}
		else if(c=='D'&&okk)
		{
			G->DestoryGraph();
			okk=0;
		}
		else if(c=='P'&&okk)
		{
			G->PutoutGraph();
		}
		else if(c=='I'&&okk)
		{
			cout<<"输入要插入点的值: ";
			cin >> v;
			G->InsertVertex(v);
		}
		else if(c=='E'&&okk)
		{
			cout<<"输入要插入弧的边上的两点值: ";
			cin>>v>>w;
			a=G->LocateVertex(v);
			b=G->LocateVertex(w);
			if(a>=0&&a<G->ReturnVert()&&b>=0&&b<G->ReturnVert())
			G->InsertVertex( v, w);
			else
			cout<<"错误\n";
		}
		else if(c=='B'&&okk)
		{
			cout<<"输入要删除点的值: ";
			cin>>v;
			a=G->LocateVertex(v);
			if(a>=0&&a<G->ReturnVert())
			G->DeleteVertex( v);
			else
			cout<<"错误\n";
		}
		else if(c=='S'&&okk)
		{
			cout<<"输入要删除弧的边上的两点值: ";
			cin>>v>>w;
			a=G->LocateVertex(v);
			b=G->LocateVertex(w);
			if(a>=0&&a<G->ReturnVert()&&b>=0&&b<G->ReturnVert())
			G->DeleteEdges(v, w);
			else
			cout<<"错误\n";
		}
		else if(c=='L'&&okk)
		{
			cout<<"要查找的点:";
			cin >>v;
			a=G->LocateVertex(v);
			if(a==-1)
			{
				cout<<"查无此点";
			}
			else
			{
				cout<<a;
			}
			cout<<endl;
		}
		else if(c=='F'&&okk)
		{
			cout<<"要查找的点:";
			cin >>v;
			a=G->LocateVertex(v);
			if(a>=0&&a<G->ReturnVert())
			cout<<G->FirstAdjVertex(v)<<endl;
			else
			cout<<"查询错误\n";
		}
		else if(c=='N'&&okk)
		{
			cout<<"要查找的两点:";
			cin >>v>>w;
			a=G->LocateVertex(v);
			b=G->LocateVertex(w);
			if(a>=0&&a<G->ReturnVert()&&b>=0&&b<G->ReturnVert())
			cout<<G->NextAdjVertex(v,w)<<endl;
			else
			cout<<"查询错误\n";
		}
		else if(c=='T'&&okk)
		{
			cout<<"块的个数:" << G->DFSTrave()<<"\n";
		}
		else if(c=='Z'&&okk)
		{
			cout<<"输入查询点到哪点:";
			cin >>t>>t1; 
			a=G->LocateVertex(t);
			b=G->LocateVertex(t1);
			if(a>=0&&a<G->ReturnVert()&&b>=0&&b<G->ReturnVert())
			{
				G->Floyd(a,b);
			}
			else
			{
				cout<<"错误"; 
			}
			cout<<endl;
		} 
		else if(c=='C'&&okk)
		{
			G->CriticalPath();
		}
		else if(c=='Q')
		{
			ok=0;
		}
		else
		{
			if(!okk)
			cout<<"请先创建图: \n";
			else
			cout << "输入错误，请再输入:\n";
		}
	}
	while(ok);
	return 0;
}
年少不知头发好
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
图的表示法：邻接矩阵和邻接链表的实现
愿君出走半生，归来时仍是少年
06-24 1609
本章主要来讨论图在数据结构中的表示方法。构成图的两个元素是顶点的有限集合和边的有限集合，顶点也称节点。边的表示格式为 (u, v)，对于无向图，边是没有顺序的，所以 (u, v) 和 (v, u) 是相同的。但是在有向图中，边是有顺序的，所以 (u, v) 和 (v, u) 代表不同的边。此外，边还有一个属性，就是边的权重（也可称为值或代价等）。 在现实世界中，图可用于表示网络，如城市和道路构成的网络、社交网络等。 下图是一个有 5 个顶点的图 数据结构中，图常用的表示方法有邻接矩阵和邻接链表
图的邻接矩阵表示法&邻接表表示法
大力海棠的博客
06-25 9224
图表示是一种多对多的关系的数据结构。因为线性表表示的是一种一对一的关系的数据结构，树表示的是一种一对多的数据结构，所以图把线性表和树都包含在内。图由一个非空的有限顶点集合和一个有限边集合组成。当我们描述图的时候，一定要包含以下两个元素：1、一组顶点：例如用Vertex表示顶点的集合。2、一组边：用Edge表示边的集合，一条边是一组顶点对。      •无向边 ：（i，j）∈Edge，i，j∈Ver...
图的邻接矩阵和邻接表表示法
小小小小杜
11-23 4030
链表是一种线性存储结构，是一对一对应关系。而树是一种层次存储结构，是一对多的对应关系。而图则是一种关系存储结构，是多对多对应关系。树和图类似于数据库中的层次模型和关系模型。图的存储结构主要有两种，分别为邻接矩阵和邻接表法，其中邻接表较难，但本质相同，都是记录结点与其邻接结点，只是方法不同而已。下面分别讨论邻接表和邻接矩阵的思想。邻接表的思想是：定义三个结点，分别为表结点，头结点，邻接表结点，表结点
图的邻接表和邻接矩阵
juryoo的专栏
05-05 7677
邻接表 一、邻接表 邻接表是图的一种链式存储结构。 邻接表中，对图中每个顶点建立一个单链表，第i个单链表中的结点表示依附于顶点Vi的边（对有向图是以顶点Vi为尾的弧）。 邻接表中的表结点和头结点结构： 表 结 点 adjvex nextarc
数据结构学习--图的邻接矩阵和邻接表存储
06-25
图的存储方式主要有两种：邻接矩阵和邻接表。这两种存储方式各有优缺点，适用于不同的场景。 邻接矩阵是一种二维数组，其中的元素表示图中顶点之间的边。对于无向图，邻接矩阵是对称的，即如果顶点i和顶点j之间有一...
图的邻接矩阵和邻接表表示的各种算法
11-05
图的邻接表 邻接矩阵表示的迪杰斯特拉算法 普里姆算法 克鲁斯卡尔算法 用c++实现 codeblocks编译通过
图的邻接矩阵和邻接表实现
11-26
图的邻接矩阵和邻接表实现， 深度搜索， 广度搜索， Dijstra最短路径
新建 DOC 文档_实现图的邻接矩阵和邻接表存储_doc_图的遍历算法_
10-01
领会图的两种主要存储结构、图基本运算算法和两种遍历算法设计内容：编写一个程序，设计带权图的邻接矩阵与邻接表的创建和输出运算，并在此基础上设计一个主程序完成如下功能：（1）建立如图所示的有向图G的邻接矩阵...
邻接表表示的AOE网与邻接矩阵表示的AOE网求解AOE网的关键路径方法
12-13
在Windows7 64位+VS2015上运行求解AOE网关键路径的算法,邻接表表示的AOE网提示网中有回路,邻接矩阵表示的AOE网显示正确的信息?使用的算法是一样的,两种方法的相关类的接口函数也一致,为什么会出现这种问题?
图的表示形式：邻接矩阵和邻接表
allway2的博客
03-21 7426
图是对象和对象之间存在的关系的有限集合。如果将对象表示为顶点（或节点），将关系表示为边，则可以得到以下两种图形： 有向图：在有向图中，一条边由一对有序的顶点（i，j）表示，其中边起源于顶点i并终止于顶点j。下面给出的是有向图的示例。 图：D.1 无向图：在无向图中，边由无序顶点对表示。下面给出了无向图的示例。 图：UD.1 表示 表示图形的两种最常见方式是：1.邻接矩阵2.邻接表 邻接矩阵 让我们考虑一个图，其中有从0到N-1编号的N个顶点和（i，j）形式的E...
图的基本术语，邻接矩阵、邻接表表示方法
公众号：风景邮递Yuan的博客
06-18 1014
图是一种与线性表和树相比更复杂的数据结构，在图形结构中，结构之间的关系可以是任意的，图中任意两个元素之间都可能相关图（Graph）是由顶点的有穷非空集合和顶点之间边的集合组成，通常表示为：G（V，E），其中G表示一个图，V是图G中顶点的集合，E是图中边的集合，顶点也就是树中的结点。无向边：若顶点vi到vj之间的边没有方向，则称这条边为无向边，用（vi，vj）表示。最多为n（n-1）/2条边。有向边：若vi到vj之间有方向，称为有向边，则用表示，最多有n（n-1）条有些图或弧具有与它相关的数字，...
一、图的定义，邻接矩阵和邻接表的实现
ThinPikachu的博客
03-20 4681
目录 一、初识图 （1）图的定义 （2）图的分类 二、图的存储结构 （1）邻接矩阵 （2）邻接表（无向图） （3）其他 一、初识图 （1）图的定义 图（Graph）是由顶点的有穷非空集合（必须存在顶点）和顶点之间边的集合组成，通常表示为：G(V，E)，其中，G表示一个图，V是图G中顶点的集合，E是图G中边的集合。 （2）图的分类 若顶点到顶点之间的边设有方向，则称这条边为无向边。如果图中任意两个顶点之间的边都是无向边，则称该图为无向图。 ...
图——图的存储结构（邻接矩阵和邻接表法）
Revendell的博客
11-03 3998
图的五种存储结构： 1、图的邻接矩阵表示法 图是由顶点和边或弧两部分组成。图的邻接矩阵（Adjacency Matrix）存储方式是用两个数组表示图，一个一维数组存储图中的顶点信息，一个二维数组（邻接矩阵）存储图中边或弧的信息。 2、图的邻接表表示法 邻接矩阵是一种不错的图存储结构，但我们发现对于边数相对顶点较少的图，这种结构是存在对存储空间的极大浪费的。因此采用邻接表（Adjacency...
数据结构学习笔记——图的存储结构（邻接矩阵、邻接表、邻接多重表和十字链表）
小宇y的博客
08-14 9737
图的常用存储结构有邻接矩阵和邻接表，另外还有十字链表、邻接多重表等等。//图的顶点数目、图的边数目 char V [ MAXSIZE ];//一维数组，存储顶点 int E [ MAXSIZE ] [ MAXSIZE ];//二维数组，边的邻接矩阵 } Graph;100//图的顶点数目、图的边数目 char V [ MAXSIZE ];//一维数组，存储顶点 int E [ MAXSIZE ] [ MAXSIZE ];//二维数组，边的邻接矩阵 } Graph;.........
图的表示——邻接表与邻接矩阵
G_H010的博客
09-21 1562
图的表示方法——邻接表与邻接矩阵
C语言 图的领接矩阵与邻接表
fpk2014的博客
06-03 2473
领接矩阵 使用一个V*V的布尔矩阵。当结点a与结点b有连接时，定义a行b列的元素值为true，否则为false。 所以我们需要一个V^2大小的数组。需要的内存空间要求很大。 注：以下图片取自：数据结构（七）图 代码实现 #include &amp;amp;lt;stdio.h&amp;amp;gt; #include &amp;amp;lt;malloc.h&amp;amp;gt; #include &amp;amp;lt;memory.
图的邻接矩阵和邻接表
最新发布
05-14
图是一种非线性数据结构，邻接矩阵和邻接表是两种表示图的方式。 邻接矩阵是用一个二维数组来表示图的。对于无向图而言，邻接矩阵是对称的，而对于有向图而言则不一定对称。如果图中有n个节点，那么邻接矩阵就是一...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值