DFS和BFS邻接矩阵实现

#include<iostream>
#include<string.h>
using namespace std;

#define MAXINT 32767    //表示∞
#define MVNum 100         //最大顶点数

typedef struct Map
{
    char DD[MVNum];
    int map[MVNum][MVNum];
    int dian,bian;    
}Map;

int Locate(Map G,char v){    //找出顶点位置
    int i;
    for(i=0;i<G.dian;i++)
        if(G.DD[i]==v)
            return i;

    return -1;
}                   

/* 创建邻接矩阵 */
void CreateMap(Map &G){
    int i,j;
    char v1,v2;
    int w;
    cout<<"请输入总顶点数和总边数"<<endl;
    cin>>G.dian>>G.bian;    //输入总顶点数和边数
    cout<<"请依次输入点的信息"<<endl;
    for(i=0;i<G.dian;i++)
        cin>>G.DD[i];      //依次输入点的信息
    for(i=0;i<G.dian;i++)
        for(j=0;j<G.dian;j++)
            G.map[i][j]=MAXINT;     //全部初始化为最大值
    cout<<"请根据边数依次输入一条边的点以及对应的权值"<<endl;
    for(int k=0;k<G.bian;k++){
        
        cin>>v1>>v2>>w;     //输入一条边依附的点以及两点之间的权值
        i=Locate(G,v1);
        j=Locate(G,v2);
        G.map[i][j]=w;
        G.map[j][i]=G.map[i][j];
    }
}

/*----------------深度优先搜索-----------------*/
bool visitedDFS[MVNum];    //对结点进行访问标志，访问后变为true
int FirstAdjVex(Map G,int u){   //找出v的第一个邻接点
    int i;
    for(i=0;i<G.dian;i++){
        if(G.map[u][i]<MAXINT && visitedDFS[i]==false){
            return i;
        }
    } 
    return -1;
}

int NextAdjVex(Map G,int u,int w){
    int i;
    for(i=w;i<G.dian;i++){
        if(G.map[u][i]<MAXINT && visitedDFS[i]==false)
            return i;
    }
    return -1;
}

void DFS(Map G,char v){
    int w,j;
    cout<<v;
    int u=Locate(G,v);
    visitedDFS[u]=true;    //v为开始访问的结点，访问后将其变为false
    for(w=FirstAdjVex(G,u);w>=0;w=NextAdjVex(G,u,w))
        if(!visitedDFS[w])
            DFS(G,G.DD[w]);
}


/*--------------广度优先搜索---------------*/
//队列部分
/*因为队列部分不需要对队列进行频繁操作，而且不
会出现超出数组而导致前后指针位置交错的问题所以可以简化队列 */
typedef struct Queue{
    int data[MVNum];
    int front,rear;
}Queue;

bool visitedBFS[MVNum];

int FirstAdjVex2(Map G,int u){   //找出v的第一个邻接点
    int i;
    for(i=0;i<G.dian;i++){
        if(G.map[u][i]<MAXINT && visitedBFS[i]==false){
            return i;
        }
    } 
    return -1;
}

int NextAdjVex2(Map G,int u,int w){
    int i;
    for(i=w;i<G.dian;i++){
        if(G.map[u][i]<MAXINT && visitedBFS[i]==false)
            return i;
    }
    return -1;
}

void InitQueue(Queue &Q){   //队列创建
    Q.front = Q.rear = 0;
    memset(Q.data,-1,sizeof(Q.data));   //将数组全部初始化为-1
}

bool QueueEmpty(Queue Q){   //判断队列是否为空
    if(Q.front == Q.rear)
        return true;
    else    
        return false;
}

void EnQueue(Queue &Q,int t){   //插入操作
    Q.data[Q.rear]=t;
    Q.rear++;
}

int DeQueue(Queue &Q){
    return Q.front++;
}

//实现部分
void BFS(Map G,char v){
    Queue Q;
    int w;
    cout<<v;
    int u = Locate(G,v);
    visitedBFS[u] = true;
    InitQueue(Q);
    EnQueue(Q,u); 
    while(!QueueEmpty(Q)){
        int r = DeQueue(Q);
        for(w=FirstAdjVex2(G,r);w>=0;w=NextAdjVex2(G,r,w))
            if(!visitedBFS[w]){
                cout<<G.DD[w];
                visitedBFS[w] = true;
                EnQueue(Q,w);
            }
    }
}

int main(){
    char choice;
    Map G;
    CreateMap(G);
    // for(int i=0;i<G.dian;i++)
    //     cout<<G.DD[i]<<" ";
    // cout<<endl;
    // for(int i=0;i<G.dian;i++){
    //     for(int j=0;j<G.dian;j++)
    //         cout<<G.map[i][j]<<" ";
    //     cout<<endl;
    // }
    cout<<"请输入深度优先搜索的起点:";
    cin>>choice;
    DFS(G,choice);
    cout<<endl;
    cout<<"请输入广度优先搜索的起点:";
    cin>>choice;
    BFS(G,choice);
    cout<<endl; 
    return 0;
}