图的邻接矩阵的C++实现

该程序实现的主要是无向图。
实现图这样的数据结构，透彻理解图的性质是很重要的。在弄明白了图的性质后再结合一些常见的编程思想，完成无向图的邻接矩阵应该不是很难。

// Graph1.h: interface for the Graph1 class.
//
//////////////////////////////////////////////////////////////////////
/********************************************************************/
/*************************图的邻接矩阵实现类的定义**********************/

#if !defined(AFX_GRAPH1_H__9F7EFFB9_7EC7_41F1_B9FC_597FC68801E7__INCLUDED_)
#define AFX_GRAPH1_H__9F7EFFB9_7EC7_41F1_B9FC_597FC68801E7__INCLUDED_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000

#include<set>
using namespace std;
#define MaxEdges 40
#define MaxNode 30
#define Max 100000
class Graph1
{
private:
int nodecount;
int edgecount;
int a[MaxNode];
//set<int> a;
int b[MaxNode][MaxNode];
public:
Graph1(int);//构造函数

int getNodeCount();//当前的节点数

int getEdgeCount();//当前的边数

void insertNode(int);//插入一个节点

void isertEdge(int ,int ,int);//插入一条边

void deleteEdge(int,int);//删除一条边

void prim(int);//生成最小树

int DFS(int);//深度优先搜索

void DFS(int node,int v[],int& n);

void BFS(int);//广度优先搜索

bool isliantong();//判断是否连通

void liantongfenliang();//连通分量的数目

int getWeight(int,int);//获得某条边的权值

int getFirstNeighbor(int);//获得所给顶点的第一个相邻节点

int getNextNeighbor(int,int);//获得某一邻接节点的下一个邻接节点

};

#endif // !defined(AFX_GRAPH1_H__9F7EFFB9_7EC7_41F1_B9FC_597FC68801E7__INCLUDED_)
/********************************************************************************/
/********************************图的实现*****************************************/
// Graph1.cpp: implementation of the Graph1 class.
//
//////////////////////////////////////////////////////////////////////

#include "Graph1.h"
#include <queue>
#include <stack>
#include<iostream>
using namespace std;

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

Graph1::Graph1(int s=MaxNode)//构造函数
{
for(int i=0;i<=s-1;i++)
for(int j=0;j<=s-1;j++)
b[i][j]=0;
nodecount=0;
for(int k=0;k<=s-1;k++)
a[k]=-1;

}

int Graph1::getNodeCount()//当前的节点数
{
return nodecount;
}

int Graph1::getEdgeCount()//当前的边数
{
return edgecount;
}

void Graph1::insertNode(int it)//插入一个节点
{
//a[nodecount++]=it;
//a.insert(it);
a[it]=it;
nodecount++;
}

void Graph1::isertEdge(int x,int y,int w)//插入一条边
{
b[x][y]=w;
b[y][x]=w;
cout<<"该边插入成功! "<<endl;
edgecount++;
}

void Graph1::deleteEdge(int x ,int y)//删除一条边
{
b[x][y]=0;
b[y][x]=0;
cout<<"边("<<x<<","<<y<<")已经成功删除!";
edgecount--;
}

void Graph1::prim(int x)//生成最小树
{
int* d=new int[getNodeCount()];
for(int id=0;id<=getNodeCount()-1;id++)
d[id]=0;
int e[10][10];
for(int im=0;im<=9;im++)
for(int rm=0;rm<=9;rm++)
e[im][rm]=0;
int min;
int node;
int l,r;

d[x]=1;
for(int i=1;i<=nodecount-1;i++)
{
min=Max;
for(int j=0;j<=nodecount-1;j++)
if(d[j]==1&&a[j]==j)
{
for(int k=0;k<=nodecount-1;k++)
if(a[k]==k&&d[k]==0&&b[j][k]>0&&b[j][k]<min)
{
node=k;
l=j;
r=k;
//e[a[j]][a[k]]=1;
min=b[l][r];
//d[a[k]]
}
}
d[node]=1;
e[l][r]=b[l][r];
}
//}

for(int ln=0;ln<=9;ln++)
for(int rn=0;rn<=9;rn++)
if(e[ln][rn]>0)
cout<<"("<<ln<<","<<rn<<",权值为"<<e[ln][rn]<<") ,";

}

void Graph1::BFS(int x)//广度优先搜索
{
int* v=new int[getNodeCount()];
for(int i=0;i<=getNodeCount()-1;i++)
v[i]=0;
cout<<x<<" ";
v[x]=1;
queue<int> q;
q.push(x);
int next;
while(!q.empty())
{//cout<<"!!!"<<endl;
//x=
x=q.front();
q.pop();

next=getFirstNeighbor(x);
//if(a[next]==-1)
// continue;
while(next!=-1)
{ if(!v[next]&&a[next]==next)
{
cout<<next<<" ";
v[next]=1;
q.push(next);
}
next=getNextNeighbor(x,next);
}
}
delete[] v;
}

// }

void Graph1::DFS(int node,int v[],int& n)
{
cout<<node<<" ";
n++;
v[node]=1;
int next=getFirstNeighbor(node);
while(next!=-1)
{

if(a[next]==next&&!v[next])
DFS(next,v,n);
next=getNextNeighbor(node,next);
}
}

int Graph1::DFS(int node)
{
int n=0;
int* v=new int[nodecount];
for(int i=0;i<=nodecount-1;i++)
v[i]=0;
DFS(node,v,n);
delete[] v;

return n;
}

bool Graph1::isliantong()//判断是否连通
{
int n=0;
n=DFS(0);
cout<<"该图的总节点数为:"<<nodecount<<"!"<<endl;
cout<<"其中一个连通分量连通的节点数为:"<<n<<"!"<<endl;
if(n==nodecount)
return true;
else return false;
}

void Graph1::liantongfenliang()//连通分量的数目
{
int n=0;
int* v=new int[nodecount];
for(int i=0;i<=nodecount-1;i++)
v[i]=0;
for(int j=0;j<=nodecount-1;j++)
if(a[j]==j&&!v[j]){
cout<<"(";
DFS(j,v,n);
cout<<") ";
//newliantong();
}
delete[] v;
}

int Graph1::getWeight(int x,int y)//获得某条边的权值
{
return b[x][y];
}

int Graph1::getFirstNeighbor(int x)//获得所给顶点的第一个相邻节点
{
int n=-1;
if(nodecount==0)
return -1;
for(int i=0;i<=nodecount-1;i++)
if(b[x][i]!=0)
{ n=a[i];
//cout<<n<<"!!"<<endl;
break;
}
return n;
}

int Graph1::getNextNeighbor(int x,int y)//获得某一邻接节点的下一个邻接节点
{
if(y==nodecount-1)
return -1;
int n=-1;
for(int i=y+1;i<=nodecount-1;i++)
if(b[x][i]!=0)
{
n=i;

break;
}
return n;
}
/*********************************************************************************/
/************************************主函数测试************************************/
#include "Graph1.h"
#include<iostream>
using namespace std;
int main(){

Graph1 G(10);

cout<<"你好,请问你向图添加几个节点?请从键盘输入!"<<endl;
int n;
cin>>n;

cout<<"请输入你要插入的"<<n<<"个节点!"<<endl;
int node;
for(int i=0;i<=n-1;i++)
{
cin>>node;
G.insertNode(node);
}
cout<<"恭喜你!你已经向图中成功添加节点!"<<endl;

cout<<"你好，请问你向图中添加几条边?请从键盘输入!"<<endl;
int e;
cin>>e;

cout<<"请输入你要添加的"<<e<<"条边以及边上对应的权值!"<<endl;
int x,y,w;
for(int j=0;j<=e-1;j++)
{cin>>x>>y>>w;
G.isertEdge(x,y,w);
}

cout<<"恭喜你!你的图已经建立成功!"<<endl;
cout<<"请输入你要查找有边相邻的节点!"<<endl;
cin>>node;

cout<<"相邻节点为"<<G.getFirstNeighbor(node)<<endl;
cout<<"第二个相邻节点为"<<G.getNextNeighbor(node,G.getFirstNeighbor(node))<<endl;

cout<<"***********************"<<endl;
cout<<"*请选择你要进行的操作:*"<<endl;
cout<<"*1--表示插入新节点! *"<<endl;
cout<<"*2--表示删除边! *"<<endl;
cout<<"*3--表示深度优先搜索! *"<<endl;
cout<<"*4--表示广度优先搜索! *"<<endl;
cout<<"*5--表示求最小生成树! *"<<endl;
cout<<"*6--判断图是否连通! *"<<endl;
cout<<"*7--求图的连通分量! *"<<endl;
cout<<"*8--插入新的边! *"<<endl;
cout<<"*0--表示结束操作! *"<<endl;
cout<<"***********************"<<endl;
int choice;
while(true)
{
cout<<endl;

cout<<"请你做出选择!"<<endl;
cin>>choice;
switch(choice)
{

case 1:
cout<<"请输入你要插入的新节点!"<<endl;
cin>>node;
//G.deleteNode(node);
G.insertNode(node);
cout<<endl;
break;

case 2:
cout<<"请输入你要删除的边!"<<endl;
cin>>x>>y;
G.deleteEdge(x,y);
cout<<endl;
break;

case 3:
cout<<"请输入你选择的起始节点!"<<endl;
cin>>node;
cout<<"深度优先搜索结果为:"<<endl;
G.DFS(node);

cout<<endl;
break;

case 4:
cout<<"请输入你选择的起始节点!"<<endl;
cin>>node;
cout<<"广度优先搜索结果为:"<<endl;
G.BFS(node);
cout<<endl;
break;

case 5:
cout<<"请输入你选择的起始节点!"<<endl;
cin>>node;
cout<<"最小生成树为:"<<endl;
G.prim(node);
cout<<endl;
break;

case 6:
if(G.isliantong())
cout<<"该图是连通的!"<<endl;
else cout<<"该图不是连通的!"<<endl;
break;

case 7:
cout<<"图的连通分量为:"<<endl;
G.liantongfenliang();
cout<<endl;
break;

case 8:
cout<<"请输入你要添加的"<<e<<"条边以及边上对应的权值!"<<endl;
cin>>x>>y>>w;
G.isertEdge(x,y,w);
break;

case 0:
cout<<"谢谢,测试完成!"<<endl;
return 0;

}
}

}