图的邻接矩阵存储就是,把图看成是一个二维矩阵,矩阵A[i][j]的值就表示节点i和节点j之间的边的权重,如果顶点i和顶点j之间没有边,则设置A[i][j] = 正无穷大。
因此,用邻接矩阵的形式存储图的结构,我们需要以下三个信息
#include
#include
#include
#include
#define max 100
typedef int data;//权重的数据类型
using namespace std;
bool visited[max];
int dfn[max];//顶点的先深编号
int count=1;
//邻接矩阵的存储结构
typedef struct{
int vertex[max];//邻接矩阵的顶点数组
data edge[max][max];//邻接矩阵的边值
int n,e;//邻接矩阵的顶点和边的个数
}mygraph;
看一个实例,假设边的权重为1表示两个顶点之间有边,边的权重为0表示两个顶点之间没有边。
void CreateGraph(mygraph *G){// 创建邻接矩阵
int i,j,k,w;
cout<<"输入顶点个数和边的个数"<<endl;
cin>>G->n>>G->e;//输入顶点个数和边的个数;
for(i=0;i<G->n;i++){
G->vertex[i]=i;
}
for(i=0;i<G->n ;i++)
for(j=0;j<G->n ;j++)
G->edge[i][j]=0;//初始化邻接矩阵
for(k=0;k<G->e;k++){
cout<<"输入边(i,j)和权重w"<<endl;
cin>>i>>j>>w;
G->edge[i][j]=w;//输入边(i,j)和权重w
G->edge[j][i]=w;
}
}
void wenjianCreateGraph(mygraph *G){// 从文件创建邻接矩阵
fstream in;
in.open("tu1.txt");
int i,j,k,w;
in>>G->n>>G->e;//输入顶点个数和边的个数;
for(i=0;i<G->n;i++){
G->vertex[i]=i;
}
for(i=0;i<G->n ;i++)
for(j=0;j<G->n ;j++)
G->edge[i][j]=0;//初始化邻接矩阵
for(k=0;k<G->e;k++){
in>>i>>j>>w;
G->edge[i][j]=w;//输入边(i,j)和权重w
G->edge[j][i]=w;
}
in.close();
}
算法时间复杂度:O(n^2+n+2e )//n个顶点初始化,n^2个边的初始化,输入无向图的2e条边
算法空间复杂度:O(n^2+n )//存储n个顶点及n^2个边值信息
void shuchugraph(mygraph *t){//打印邻接矩阵的信息
for(int i=0;i<t->n ;i++){
cout<<"\t"<<i;
}
cout<<endl;
for(int i=0;i<t->n ;i++){
cout<<i<<"\t";
for(int j=0;j<t->n ;j++){
if(t->edge[i][j]==0){
cout<<"∞\t";
}
else
cout<<t->edge[i][j]<<"\t";
}
cout<<endl;
}
}
图的邻接表存储,就是对于每个顶点v来说,和这个顶点v相连的所有邻接点构成一个线性表。
我们需要把顶点分成两类,一类是主顶点,一类是和顶点链接的边顶点。
对于每个主顶点,我们需要存储以下信息:
typedef struct {//顶点表节点
int dingdian;//顶点表节点
bool zouguo;//标记节点是否被访问过
Edgenode *firstedge;//边链表头指针
}Vertex;
对于每一个边顶点,我们需要存储以下信息。
typedef struct node{//边表节点
int xiabiao;//顶点下标
data cost;/和主顶点邻接的边的权重
struct node *next;//指向下一边表节点的指针
}Edgenode;
那么整个图就可以用一个主顶点数组来表示,同时需要指明图的边的个数和顶点的个数。
typedef struct {//图的邻接表
Vertex vexlist[max];//顶点数组
int n,e;//顶点个数和边的个数
}adjgraph;
输入顶点个数和边的个数
初始化顶点邻接表
根据给定的邻接顶点i和j,创建边顶点p和q分别存储顶点i和j的信息,让主顶点i指向q,且让主顶点j指向边顶点q。
void CreateadjGraph(adjgraph *G){// 创建邻接表
int i,k,j;
data weight;
cout<<"请输入顶点个数和边的个数"<<endl;
cin>>G->n >>G->e ;
for(i=0;i<G->n;i++){
G->vexlist[i].dingdian=i;
G->vexlist[i].firstedge=NULL;//初始化邻接表
}
for(k=0;k<G->e ;k++){
cout<<"输入边(i,j)和权重w"<<endl;
cin>>i>>j>>weight;
Edgenode* p=new Edgenode;
p->xiabiao =j;p->cost =weight;
p->next =G->vexlist[i].firstedge ;
G->vexlist[i].firstedge =p;
Edgenode* q=new Edgenode;
q->xiabiao =i;q->cost =weight;
q->next =G->vexlist[j].firstedge ;
G->vexlist[j].firstedge =q;
}
}
void wenjianCreateadjGraph(adjgraph *G){// 从文件创建邻接表
fstream in;
in.open("tu2.txt");
int i,k,j;
data weight;
in>>G->n >>G->e ;
for(i=0;i<G->n;i++){
G->vexlist[i].dingdian=i;
G->vexlist[i].firstedge=NULL;//初始化邻接表
}
for(k=0;k<G->e ;k++){
in>>i>>j>>weight;
Edgenode* p=new Edgenode;
p->xiabiao =j;p->cost =weight;
p->next =G->vexlist[i].firstedge ;
G->vexlist[i].firstedge =p;
Edgenode* q=new Edgenode;
q->xiabiao =i;q->cost =weight;
q->next =G->vexlist[j].firstedge ;
G->vexlist[j].firstedge =q;
}
in.close();
}
void shuchuadjgraph(adjgraph *t){//打印邻接表
for(int i=0;i<t->n ;i++){
cout<<i<<":\t";
Edgenode *p;
p=t->vexlist[i].firstedge;
while(p!=NULL){
cout<<p->xiabiao<<"\t";
p=p->next ;
}
cout<<endl;
}
}
void jzhuanhuanb(mygraph *G,adjgraph *T){//将邻接矩阵G转化为邻接表T
T->n=G->n ;//初始化邻接表
T->e =G->e;//初始化邻接表
for(int i=0;i<G->n;i++ ){//初始化邻接表
T->vexlist[i].dingdian =i;
T->vexlist[i].firstedge=NULL;
}
for(int j=0;j<G->n;j++){
for(int k=0;k<G->n ;k++){
if(G->edge[j][k]!=0){
Edgenode *p=new Edgenode;
p->xiabiao=G->vertex[k];//顶点赋值
p->cost =G->edge[j][k]; //边权重赋值
p->next =T->vexlist[j].firstedge ;
T->vexlist[j].firstedge=p;
}
}
}
}
思路同上,先初始化,然后遍历每个顶点的邻接顶点,然后给邻接矩阵赋值即可。
void bzhuanhuanj(mygraph *G,adjgraph *T){//将邻接表转换为邻接矩阵
Edgenode *p;
G->n =T->n;//初始化邻接矩阵
G->e =T->e ;//初始化邻接矩阵
int i,j;
for(i=0;i<G->n;i++){
for( j=0;j<G->n;j++){
G->edge[i][j]=0;//初始化邻接矩阵
}
}
for(int k=0;k<G->n;k++){
p=T->vexlist[k].firstedge ;
while(p!=NULL){
G->edge[k][p->xiabiao]=p->cost;//将边权重赋值
p=p->next ;
}
}
}
思路:借助一个标记数组,标记了每个顶点是否被访问过。
void DFSX(mygraph *G,int x){//辅助深度递归 (通过邻接矩阵)
visited[x]=true;
cout<<G->vertex[x]<<" ";
for(int j=0;j<G->n;j++){
if(!visited[j]&&G->edge[x][j]!=0)
DFSX(G,G->vertex[j]);
}
}
void diguishen(mygraph *G){ //邻接矩阵深度递归算法
for(int i=0;i<G->n;i++){//将每个节点标记为未访问过
visited[i]=false;
}
int count=1;//森林个数
for(int i=0;i<G->n;i++){
if(!visited[i]){
cout<<"森林"<<count++<<":";
DFSX(G,i);
cout<<endl;
}
}
}
一般对于所有的递归算法来说,要把它变成非递归算法,则要利用栈。
算法原理:
void feidiguishen2(mygraph *G){ //邻接矩阵深度非递归算法
for(int l=0;l<G->n ;l++)//将每个节点标记为未访问过
visited[l]=false;
stack<int>s;
int count=1;//森林个数
for(int j=0;j<G->n;j++){
if(!visited[j]){
cout<<"森林"<<count++<<":";
visited[j]=true;
s.push(j);
cout<<G->vertex[j]<<" ";
while(!s.empty() ){
int t = s.top();
bool flag = false;
for(int k=0;k<G->n ;k++){
if(G->edge[t][k]!=0){
if(!visited[k]){
visited[k]=true;
cout<<G->vertex[k]<<" ";
s.push(k);
flag = true;
break ;
}
}
}
if (flag == false )
s.pop() ;
}
cout<<endl;
}
}
}
思路一样,就是代码不一样
void DFSX2(adjgraph *G,int x){//邻接表深度递归辅助算法
Edgenode *p;
visited[x]=true;//标记为访问过
cout<<G->vexlist[x].dingdian<<" ";
p=G->vexlist[x].firstedge;
while(p){
if(!visited[p->xiabiao])
DFSX2(G,p->xiabiao);
p=p->next ;
}
}
void diguishen2(adjgraph *G){//邻接表深度递归算法
for(int i=0;i<G->n;i++){//将每个节点标记为未访问过
visited[i]=false;
}
int count=1;
for(int i=0;i<G->n;i++){//遍历每一个节点
if(!visited[i]){
cout<<"森林"<<count++<<":";
DFSX2(G,i);
cout<<endl;
}
}
}
void feidiguishen(adjgraph *G){//邻接表深度非递归算法
stack<int>s;
Edgenode *p;
for(int j=0;j<G->n;j++){//将每个节点标记为未访问过
visited[j]=false; }
int count=1;//森林数目
for(int i=0;i<G->n;i++){//遍历每个节点
if(!visited[i]){
cout<<"森林"<<count<<":";
visited[i]=true;
s.push(i);
cout<<G->vexlist[i].dingdian<<" ";
p=G->vexlist[i].firstedge;
while(!s.empty()){
p=G->vexlist[s.top()].firstedge ;
bool flag = false;
while(p){
if(!visited[p->xiabiao ]){
visited[p->xiabiao ]=true;
cout<<G->vexlist[p->xiabiao].dingdian<<" ";//输出该节点
s.push(p->xiabiao );
p=G->vexlist[p->xiabiao].firstedge ;
flag = true;
break;
}
else{
p=p->next ;
}
}
if(flag == false){
s.pop() ;
}
}
cout<<endl;
count++;
}
}
}
广度优先遍历和我们之前将的二叉树的层序遍历几乎一样。有一个不同的地方就是图不一定是连通的,可能有几个森林,而二叉树一定是连通的。
思路:借助队列来实现。
void guangdu2(mygraph *G) {//邻接矩阵广度优先遍历
for(int j=0;j<G->n;j++){
visited[j]=false;
}
queue<int>s;
int count=1;
for(int i=0;i<G->n;i++){
if(!visited[i]){
cout<<"森林"<<count++<<":";
visited[i]=true;
cout<<G->vertex[i]<<" ";
s.push(G->vertex[i]);
while(!s.empty() ){
int k=s.front() ;
s.pop() ;
for(int j=0;j<G->n;j++){
if(G->edge [k][j]!=0){
if(!visited[j]){
visited[j]=true;
cout<<G->vertex[j]<<" ";
s.push(G->vertex[j]);
}
}
}
}
cout<<endl;
}
}
}
void guangdu(adjgraph *G){//邻接表广度优先遍历
for(int j=0;j<G->n;j++){
visited[j]=false;
}
queue<int>s;
Edgenode *p;
int count=1;
for(int i=0;i<G->n;i++){
if(!visited[i]){
cout<<"森林"<<count++<<":";
visited[i]=true;
cout<<G->vexlist[i].dingdian<<" ";
s.push(G->vexlist[i].dingdian);
while(!s.empty() ){
p=G->vexlist[s.front()].firstedge;
s.pop() ;
while(p!=NULL){
if(!visited[p->xiabiao]){
visited[p->xiabiao]=true;
cout<<G->vexlist[p->xiabiao].dingdian<<" ";
s.push(p->xiabiao);
}
p=p->next;
}
}
cout<<endl;
}
}
}
void zrh(){
int x=0;//用来判断当前的无向图是用邻接矩阵还是邻接表来表示的,0代表邻接矩阵,1代表邻接表
cout<<"-----------------------------------------------------------------"<<endl;
cout<<"0.退出 |"<<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<<"9.深度优先递归遍历无向图 |"<<endl;
cout<<"10.深度优先非递归遍历无向图 |"<<endl;
cout<<"11.广度优先遍历无向图 |"<<endl;
cout<<"-----------------------------------------------------------------"<<endl;
mygraph g;//创建无向图 的邻接矩阵
adjgraph t;//创建无向图的邻接表
int n;
cin>>n;
while(n){
switch(n){
case 1:
wenjianCreateGraph(&g);
x=0;
break;
case 2:
wenjianCreateadjGraph(&t);
x=1;
break;
case 3:
CreateGraph(&g);
x=0;
break;
case 4:
CreateadjGraph(&t);
x=1;
break;
case 5:
shuchugraph(&g);
x=0;
break;
case 6:
shuchuadjgraph(&t);
x=1;
break;
case 7:
adjgraph t1;
cout<<"邻接矩阵为:"<<endl;
shuchugraph(&g);
cout<<"转化为邻接表后为:"<<endl ;
jzhuanhuanb(&g,&t1);
shuchuadjgraph(&t1);
break;
case 8:
mygraph t2;
cout<<"邻接表为:"<<endl;
shuchuadjgraph(&t);
cout<<"转化为邻接矩阵后为:"<<endl ;
bzhuanhuanj(&t2,&t);
shuchugraph(&t2);
break;
case 9:
if(x==1){
diguishen2(&t);
}
else{
diguishen(&g);
}
break;
case 10:
if(x==1){
feidiguishen(&t);
}
else{
feidiguishen2(&g);
}
break;
case 11:
if(x==0){
guangdu2(&g);
}
else{
guangdu(&t);
}
break;
default :
n=0;
break;
}
cout<<"-----------------------------------------------------------------"<<endl;
cout<<"0.退出 |"<<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<<"9.深度优先递归遍历无向图 |"<<endl;
cout<<"10.深度优先非递归遍历无向图 |"<<endl;
cout<<"11.广度优先遍历无向图 |"<<endl;
cout<<"-----------------------------------------------------------------"<<endl;
if(x==0)
cout<<"当前无向图为邻接矩阵表示法,请根据提示选择正确的操作:"<<endl;
else
cout<<"当前无向图为邻接表表示法,请根据提示选择正确的操作:"<<endl;
if(n!=0)
cin>>n;
}
}