网的邻接矩阵表示法以及对于邻接矩阵表示法的DFS遍历

#include<iostream>
using namespace std;
#include <vector>
#include <iomanip>

#define MaxInt 32767//极大值（正无穷）
#define MVNum 100//最大顶点数

typedef struct {
    char Vexs[MVNum];//顶点表
    int Arcs[MVNum][MVNum];//图的邻接矩阵
    int vexnum, arcnum;//图当前所用顶点数和总边数
}AMGraph;

int LocateVex(const AMGraph G,const char u)
{
    //-1表示没找到
    int ret = -1;
    for (int i = 0; i < G.vexnum; i++)
    {//遍历顶点表 找值相同的 返回下标
        if (u == G.Vexs[i])
        {
            ret = i;
        }
    }
    return ret;
}

void CreateUDN(AMGraph& G)
{
    cout << "输入总顶点数和总边数" << endl;
    cin >> G.vexnum >> G.arcnum; //输入总顶点数和总边数

    //存入顶点信息
    cout << "输入顶点信息" << endl;
    for (int i = 0; i < G.vexnum; ++i)
    {
        cin >> G.Vexs[i];
    }

    //初始化邻接矩阵 全置为无穷大
    for (int i = 0; i < G.vexnum; ++i)
    {
        for (int j = 0; j < G.vexnum; ++j)
        {
            G.Arcs[i][j] = MaxInt;//或者用INT32_MAX
            //如果不是网 则赋上0
        }
    }

    //共arcnum条边 依次输入
    for (int k = 0; k < G.arcnum; ++k)
    {
        //需要知道该点依附于哪两个顶点 以及权为多少
        int i, j, weight; //i，j表示下标 位置需要函数找到
        char v1, v2;
        cout << "输入边信息：（起始顶点、结束顶点、权）" << endl;
        cin >> v1 >> v2 >> weight;//如果不是网 则将weight改为1

        i = LocateVex(G, v1);//找v1在顶点表的位置
        j = LocateVex(G, v2);//找v2在顶点表的位置
        G.Arcs[i][j] = weight;
        //对于无向网 结果为对称的
        G.Arcs[j][i] = G.Arcs[i][j];//如果为有向图、有向网 则删除这一行
    }
}

//深度优先遍历算法
void DFS_AM(AMGraph& G,char v)//传入一个图、一个起始顶点
{
    //定义一个vector容器作标志 用数组不太合适 数组得确定长度 我们需要的是一个顶点数相同大小的容器
    static vector<int> visited(G.vexnum,0);//要用静态！！！要么就放外面 不然会重置 导致无限递归

    int loc = LocateVex(G, v);//找到这个顶点在顶点表中的下标

    cout << G.Vexs[loc]; //访问该顶点 输出结果

    //标志数组visit对应的元素被访问了，标记1
    visited[loc] = 1;

    /*
    一个小改进
    其实当visited中的数全是1时 就已经不需要再找了 可以提前结束递归调用
    添加一个检查 visited 向量的循环，以判断是否所有顶点都已被访问。
    如果是这样，就可以提前return 不进入递归
    */
    bool allVisited = true; // 检查是否所有顶点都被访问

    for (int i = 0; i < G.vexnum; ++i)
    {
        if (visited[i] == 0) // 存在未访问的顶点
        {
            allVisited = false;
            break;
        }
    }

    if (allVisited) {
        return; // 所有顶点都被访问，提前终止递归
    }

    //从邻接矩阵的某一行的第1个元素开始-遍历到该行第n个元素
    for (int w = 0; w < G.vexnum; ++w)
    {
        //如果找到一个相连的顶点，并且该顶点还没有被访问过，进入递归函数
        if ((G.Arcs[loc][w] != MaxInt) && visited[w] == 0)
        {
            //找到后进行递归调用
            //在这里找到的是一个下标 
            //但是我的函数传的是一个字符 
            //所以还需要根据下标找到对应的字符
            char nextVertex = G.Vexs[w];
            DFS_AM(G, nextVertex);
        }
    }
}

void PrintVertexTable(const AMGraph& G)
{
    cout << "顶点表 Vexs:" << endl;
    for (int i = 0; i < G.vexnum; ++i)
    {
        cout << "下标：" << i << " 字符" << G.Vexs[i] << endl;
    }
    cout << endl;
}

void PrintAdjacencyMatrix(const AMGraph& G)
{
    cout << "邻接矩阵 Arcs:" << endl;
    for (int i = 0; i < G.vexnum; ++i)
    {
        for (int j = 0; j < G.vexnum; ++j)
        {
            cout << setw(5) << G.Arcs[i][j] << " "; // 设置字段宽度为5
        }
        cout << endl;
    }
    cout << endl;
}

int main()
{
    AMGraph G;
    CreateUDN(G);

    PrintVertexTable(G);
    PrintAdjacencyMatrix(G);

    char first;
    cout << "希望以哪个顶点开始遍历？" << endl;
    cin >> first;
    cout << "从"<<first<<"处深度优先遍历图G" << endl;
    DFS_AM(G, first);
    return 0;
}