无向图遍历

 大神：https://www.jianshu.com/p/e58665864d54

DFS

依次输入无向图的顶点个数、边的总条数以及每一条边，如0 1则表示顶点A和顶点B之间有边，然后创建该图的邻接矩阵的存储结构。请补充算法，对该图进行深度优先遍历，输出其遍历结果。

输入：6   11

0 1  0 5  1 5  0 3  5 3  0 2  2 3  5 4  3 4  0 4  2 4

输出：ABFDCE 

 

#include<iostream>
using namespace std;
#define UNVISITED 0
#define VISITED 1

class AdjMatrixUndirGraph
{
public:
    int vexNum, edgeNum;    // 顶点个数和边数
    int **Matrix;           // 邻接矩阵
    char *elems;            // 顶点数据
    bool *tag;

    AdjMatrixUndirGraph(char es[], int vertexNum);
    int FirstAdjVex(int v) ;          // 返回顶点v的第一个邻接点
    int NextAdjVex(int v1, int v2);   // 返回顶点v1的相对于v2的下一个邻接点
    void Display();                   // 图的输出
    void DFS(int v);                  // 深度遍历
};

AdjMatrixUndirGraph::AdjMatrixUndirGraph(char es[], int vertexNum)
{
    vexNum = vertexNum;
    edgeNum = 0;
    elems = new char[vexNum];
    int u, v;
    for(v = 0; v < vexNum; v++)
    {  // 初始化标志数组
        elems[v] = es[v];
    }

    tag = new bool[vexNum];        // 生成标志数组
    for(v = 0; v < vexNum; v++)
    {  // 初始化标志数组
        tag[v] = UNVISITED;
    }

    Matrix = (int **)new int *[vexNum];// 生成邻接矩阵
    for (v = 0; v < vexNum; v++)
    {  // 生成邻接矩阵的行
        Matrix[v] = new int[vexNum];
    }

    for (u = 0; u < vexNum; u++)
    {
        for (v = 0; v < vexNum; v++)
        {  // 为邻接矩阵元素赋值
            Matrix[u][v] = 0;
        }
    }
}

int AdjMatrixUndirGraph::FirstAdjVex(int v)
// 操作结果：返回顶点v的第1个邻接点
{
    int k;
    for(k=0;k<vexNum;k++){
        if(Matrix[v][k]==1&&tag[k]==UNVISITED){
            return k;
        }
    }
    return -1;    // 返回-1表示无邻接点
}

int AdjMatrixUndirGraph::NextAdjVex(int v1, int v2)
// 操作结果：返回顶点v1的相对于v2的下1个邻接点
{
    int k;
    for(k=v2+1;k<vexNum;k++){
        if(Matrix[v1][k]==1&&tag[k]==UNVISITED){
            return k;
        }
    }
    return -1;    // 返回-1表示无邻接点
}

void AdjMatrixUndirGraph::Display()
{
    int i,j;
     for(i=0;i<vexNum;i++){
        for(j=0;j<vexNum;j++){
            cout<<Matrix[i][j]<<" ";
        }
        cout<<endl;
     }
}

void AdjMatrixUndirGraph::DFS(int v)
{        int w;//返回的是对应的数字 而不是顶点信息(ABCD啥的)
         cout<<elems[v];
         tag[v]=1;
         w=FirstAdjVex(v);//找到v的第一个临界点 找不到的话返回-1
         while(w!=-1){
            DFS(w);
            w=NextAdjVex(v,w);
         }

}

int main()
{
    char vexs[] = {'A', 'B', 'C', 'D','E','F','G','H','I','J','K','L',
            'M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z'};
    int n,t,i,x,y;
    cout<<"请输入无向图的顶点个数：";
    cin>>n;
    AdjMatrixUndirGraph g(vexs, n);//新建完毕

    cout<<"请输入边的总条数：";
    cin>>t;
    cout<<"请依次输入边，如0 1表示A和B之间有边："<<endl;
    for (i = 1; i <=t; i++)
    {
        cin>>x>>y;
        g.Matrix[x][y]= g.Matrix[y][x]= 1;
    }

    cout << endl <<"原无向连通图的邻接矩阵如下：" << endl;
    g.Display();
    cout << endl;

    cout << "深度遍历序列为:" << endl;
    g.DFS(0);
    cout<<endl;

    return 0;
}

BFS

有错误还没改不知道哪里出了问题

#include<bits/stdc++.h>
using namespace std;
#define MAX_NUM 100
typedef struct Graph{
     char vexnum,arcnum;//顶点数，边数
     char vertex[MAX_NUM];//顶点信息数组
     int arcs[MAX_NUM][MAX_NUM];//邻接数组
}Graph;
bool visited[MAX_NUM];
typedef struct{
     int data[MAX_NUM];//顺序队列 这是队列的元素空间
     int front;//头指针指示器
     int rear;//尾指针  注意啊这是int类型的
}Queue;
void InitQueue(Queue *Q){ //初始化队列

    Q->front=Q->rear=0;
}
void EnterQueue(Queue *Q,int e){
    int x;
     /*
     if((Q->rear+1)%MAX_NUM==Q->front){
        return false;
     }*/
     Q->data[Q->rear]=x;
     Q->rear=(Q->rear+1)%MAX_NUM;

}
void DeleteQueue(Queue *Q,int *x){

     *x=Q->data[Q->front];
     Q->front=(Q->front+1)%MAX_NUM;

}
int Empty(Queue Q){

    if(Q.front==Q.rear){
        return 1;//队列为空 返回真
    }
    else{ return 0;}

}
void CreateGraph(Graph *g){
      int i,j;
      int u,v;//输入的边的信息

      cout<<"输入顶点数和边数"<<endl;
      cin>>g->vexnum>>g->arcnum;
      for(i=0;i<g->vexnum;i++){
         visited[i]=false;//初始化判断数组都为false 所有点都未访问
      }
      cout<<"输入顶点信息数组"<<endl;
      for(i=0;i<g->vexnum;i++){
         cin>>g->vertex[i];//可以输入ABCDE了
      }
    //对邻接矩阵的 初始化 和有联系的点的信息化
      for(i=0;i<g->vexnum;i++){
        for(j=0;j<g->vexnum;j++){
            g->arcs[i][j]=0;//初始化邻接矩阵啦
        }
      }
      for(j=0;j<g->arcnum;j++){
         cout<<"请依次输入边,如0 1 表示A和B之间有边"<<endl;
         cin>>u>>v;
         g->arcs[u][v]=1;
         g->arcs[v][u]=1;//这样就联系起来啦 输入有联系的边的信息了
      }
}
int FirstVertex(Graph g,int v){//int类型哦

       int k=0;
       for(k=0;k<g.vexnum;k++){
          if(g.arcs[v][k]==1&&visited[k]==false){
             return k;
          }
       }
       return -1;
}
int NextVertex(Graph g,int v1,int v2){

          int k;
          for(k=v2+1;k<g.vexnum;k++){
              if(g.arcs[v1][k]==1&&visited[k]==false){
                  return k;
               }
          }
          return -1;
}
void BreadthFirstSearch(Graph *g,int v0){ //bfs遍历
         Queue Q;
         int v,i;
         visited[v0]=true;
         cout<<g->vertex[v0]<<" ";
         InitQueue(&Q);//初始化队列
         EnterQueue(&Q,v0);//向队列中插入元素
         /*while(!Empty(Q)){//为空返回真 此条件是判断队列不为空
            DeleteQueue(&Q,&v);//队首元素v出队
            w=FirstVertex(g,v);
            while(w!=-1){
                if(!visited[w]){
                    visited[w]=1;
                    EnterQueue(&Q,W);
                }
                w=NextVertex(g,v,w);
            }
         }*/
         while(!Empty(Q)){
            DeleteQueue(&Q,&v);
            for(i=0;i<g->vexnum;i++){
                if(g->arcs[v][i]==1&&visited[i]==false){
                    visited[i]=true;
                    cout<<g->vertex[i]<<" ";
                    EnterQueue(&Q,i);
                }
            }
         }
}
//操作的是数字 输出的时候让数字对应vertex[]数组  vertex[0]=A
void ShowGraph(Graph *g){
     cout<<"输出图的信息"<<endl;
     int i,j;
     for(i=0;i<g->vexnum;i++){
        for(j=0;j<g->vexnum;j++){
            cout<<g->arcs[i][j]<<" ";
        }
        cout<<endl;
     }
}

int main(){

     Graph *g;
     int i;
     g=(Graph*)malloc(sizeof(Graph));
     CreateGraph(g);
     for(i=0;i<g->vexnum;i++){
        BreadthFirstSearch(g,i);
        cout<<endl;
     }
     ShowGraph(g);
}