无向图有向图邻接矩阵表示法

1.无向图的邻接矩阵表示法验证程序 

采用邻接矩阵表示无向图，完成图的创建、图的深度优先遍历、图的广度优先遍历操作。其中图的顶点信息是字符型，图中顶点序号按字符顺序排列。本输入样例中所用的图如下所示：

输入描述:

第一行输入两个值，第一个是图中顶点的个数，第二个是图中边的条数
第二行输入各顶点的信息，即输入每个顶点字符
第三行开始输入每条边，每条边的形式为两个顶点的序号，中间以空格隔开，输入完一条边换行

输出描述:

首先输出图的顶点信息，输出完毕换行
接着输出图的邻接矩阵，假如图中有n个顶点，则输出形式为n行n列的邻接矩阵，输出完毕换行
接下来一行输出从图的第一个顶点开始进行深度优先遍历的序列，中间以空格隔开，输出完毕换行
最后一行输出从图的第一个顶点开始进行广度优先遍历的序列，中间以空格隔开，输出完毕换行

---

输入样例:

5 7
A B C D E
0 1
0 2
0 3
1 2
1 3
2 4
3 4

输出样例:

A B C D E
0 1 1 1 0
1 0 1 1 0 
1 1 0 0 1
1 1 0 0 1
0 0 1 1 0
A B C E D
A B C D E

#include <iostream>
#include <queue>

using namespace std;
typedef char T;

const int maxSize=50;
int i,j,k;

class mGraph
{
public:
    mGraph(T a[],int n,int e);
    ~mGraph(){};
    void DFStraverse(int v);//shen
    void BFStraverse(int v);//guang
    void printMatrix();
private:
    T vertex[maxSize];       //存放图中顶点的数组
    int visited[maxSize];
    int arc[maxSize][maxSize];//存放图中边的数组
    int vertexNum,arcNum;    //图的定点数和边数
};

mGraph::mGraph(T a[],int n,int e)
{
    for(i=0;i<maxSize;i++)
            visited[i]=0;
    vertexNum=n;arcNum=e;
    for(i=0;i<vertexNum;i++)
        vertex[i] = a[i];
    for(i=0;i<vertexNum;i++)//初始化邻接矩阵
        for(j=0;j<vertexNum;j++)
            arc[i][j]=0;
    for(k=0;k<arcNum;k++)
    {
        cin>>i>>j;
        arc[i][j]=1;arc[j][i]=1;
    }
}

void mGraph::DFStraverse(int v)
{
    if(!visited[v])
    cout<<vertex[v]<<" ";visited[v]=1;
    for(j=0;j<vertexNum;j++)
        if(arc[v][j]==1 && visited[j]==0) DFStraverse(j);
}

void mGraph::BFStraverse(int v)
{
    queue<int>Q;
    if(!visited[v])
    cout<<vertex[v]<<" ";visited[v]=1;
    Q.push(v);
    while(Q.empty()!=true){
        v=Q.front();
        Q.pop();
        for(j=0;j<vertexNum;j++)
            if(arc[v][j]==1&&visited[j]==0){
            cout<<vertex[j]<<" ";
            visited[j]=1;
            Q.push(j);
        }
    }
}

void mGraph::printMatrix()
{
    for(i=0;i<vertexNum;i++){//初始化邻接矩阵
        for(j=0;j<vertexNum;j++){
            cout<<arc[j][i]<<" ";
        }
        cout<<endl;
    }
}

int main()
{
    int n,e;
    while(cin>>n>>e){
        T a[maxSize];
    for(i=0;i<n;i++)
        cin>>a[i];
        for(i=0;i<n;i++)
        cout<<a[i]<<" ";
        cout<<endl;
    mGraph M(a,n,e);
    mGraph A(M);
    M.printMatrix();
    for(i=0;i<n;i++)
    M.DFStraverse(i);
    cout<<endl;
    for(i=0;i<n;i++)
    A.BFStraverse(i);
    cout<<endl;
    }
}

2.向图的邻接表表示法验证程序 
 
 

  
  用邻接表表示有向图，完成图的创建、图的深度优先遍历、图的广度优先遍历操作。其中图的顶点信息是字符型，图中顶点序号按字符顺序排列，边的输入按照边的顶点序号从小到大的顺序排列，如下图的边的输入顺序为
  
  0 1
  
  ，
  
  0 2
  
  ，
  
  0 3
  
  ，
  
  1 2
  
  ，
  
  1 3
  
  ，
  
  2 4
  
  ，
  
  3 4
  
  共七条边，邻接表的边结点采用头插法。本输入样例中所用的图如下所示：

 
 
输入描述:
第一行输入两个值，第一个是图中顶点的个数，第二个是图中边的条数
第二行输入各顶点的信息，即输入每个顶点字符
第三行开始输入每条边，每条边的形式为两个顶点的序号，中间以空格隔开，输入完一条边换行
输出描述:
首先输出图的顶点信息，输出完毕换行
接着输出图的邻接表，格式为首先输出第一个顶点，接着输出该顶点的所有的临界点的序号，换行，然后输出下一个顶点及邻接点，以此类推
接下来一行输出从图的第一个顶点开始进行深度优先遍历的序列，中间以空格隔开，输出完毕换行
最后一行输出从图的第一个顶点开始进行广度优先遍历的序列，中间以空格隔开，输出完毕换行
 
 
输入样例:
5 7
A B C D E
0 1
0 2
0 3
1 2
1 3
2 4
3 4
输出样例:
A B C D E
A 3 2 1
B 3 2 
C 4 
D 4 
E 
A D E C B 
A D C B E
#include <iostream>
#include <queue>

using namespace std;
typedef char T;
const int maxSize = 10;
int i,j,k;

struct arcNode
{
    int adjvex;//临街点域
    arcNode *next;
};

struct vertexNode
{
    T vertex;
    arcNode *firstedge;
};

class AlGraph
{
public:
    AlGraph(T a[],int n,int e);
   // ~AlGraph();
    void DFStraverse(int v);
    void BFStraverse(int v);
    void printEveryVertex(int v);
    void DFS();
    void BFS();
private:
    vertexNode adjlist[maxSize];//存放顶点的数组
    int vertexNum,arcNum;//顶点数和边数
    int visited[maxSize];
};

AlGraph::AlGraph(T a[],int n,int e)
{
    vertexNum=n,arcNum=e;
    for(i=0;i<vertexNum;i++)
        visited[i]=0;
    for(i=0;i<vertexNum;i++)
    {
        adjlist[i].vertex=a[i];
        adjlist[i].firstedge=NULL;
    }
    for(k=0;k<arcNum;k++)
    {
        arcNode *s;
        cin>>i>>j;
        s=new arcNode;
        s->adjvex=j;
        s->next=adjlist[i].firstedge;
        adjlist[i].firstedge=s;
    }
}

void AlGraph::DFStraverse(int v)//深度优先遍历；
{
        cout<<adjlist[v].vertex<<" ";visited[v]=1;
    arcNode *p=new arcNode;
    p=adjlist[v].firstedge;
    while(p!=NULL){
            j=p->adjvex;
        if(visited[j]==0) DFStraverse(j);
        p=p->next;
    }
}

void AlGraph::BFStraverse(int v)
{
    queue<int>Q;
    cout<<adjlist[v].vertex<<" ";
    visited[v]=1;
    Q.push(v);
    while(!Q.empty()){
        v=Q.front();
        Q.pop();
        arcNode *p=adjlist[v].firstedge;
        while(p!=NULL){
                j=p->adjvex;
            if(visited[j]==0){
                cout<<adjlist[j].vertex<<" ";
                visited[j]=1;
                Q.push(j);
            }
            p=p->next;
        }
    }
}

void AlGraph::printEveryVertex(int v)
{
    arcNode *p=new arcNode;
    p = adjlist[v].firstedge;
    cout<<adjlist[v].vertex<<" ";
    while(p!=NULL)
    {
        cout<<p->adjvex<<" ";
        p=p->next;
    }
    cout<<endl;
}

void AlGraph::DFS()
{
	for(i = 0;i<vertexNum;i++)
	{
		if(visited[i] == 0)
			DFStraverse(i);
	}
	cout<<endl;
}

void AlGraph::BFS()
{
	for(i = 0;i<vertexNum;i++)
	{
		if(visited[i] == 0)
			BFStraverse(i);
	}
	cout<<endl;
}

int main()
{
    T a[maxSize];
    int n,e;
    cin>>n>>e;
    for(i=0;i<n;i++)
        cin>>a[i];
    for(i=0;i<n;i++)
        cout<<a[i]<<" ";
    cout<<endl;
    AlGraph M(a,n,e);
    AlGraph M2(M);
    for(i=0;i<n;i++)
    M.printEveryVertex(i);
    M.DFS();
    M2.BFS();

}