c++实现邻接表实现的图，以及深度优先搜索，和广度优先搜索

#include <iostream>
#include <string>
#include <stack>
#include <queue>

//深度优先 (使用栈，先进后出，后进先出)
//广度优先（使用队列，先进先出，后进后出）
#define max_verts 10

using namespace std;

//邻接矩阵构建图

class vertex //构建自定义的顶点
{
public:
    vertex(string label)
    {
        this->label=label;
    }

public:
    string label;
    bool isvisted= false;
};


class graph
{
public:
    graph();
    ~graph();
    void add_vertex(string label);
    void add_edge(int start,int end);
    void printmatrix();
    void showvertex(int a);
    void DFS();//深度优先搜索

    void BFS();
private:
    vertex* vertexlist[max_verts]; //数组的总容量
    int nverts;//图中当前的节点数
    int adjmat[max_verts][max_verts];//邻接矩阵

    int getadjunivisitedvertex(int v);//找当前顶点的下一个邻接定点
};


void graph::BFS() {
    queue<int> myqueue;
    vertexlist[0]->isvisted= true;
    showvertex(0);
    myqueue.push(0);//访问过的每一个节点都要放入队列，如同于深度优先搜索的时候访问过的每个节点都要放入栈里
    int v1;
    while (myqueue.size()>0)
    {
        v1=myqueue.front();
        myqueue.pop();
        int v2=getadjunivisitedvertex(v1);
        while (v2!=-1)
        {
            vertexlist[v2]->isvisted= true;
            showvertex(v2);
            myqueue.push(v2);//将访问过的节点全部放入队列中
            v2=getadjunivisitedvertex(v1);
        }
    }
    cout<<endl;

    for (int i = 0; i <nverts ; i++) {
        vertexlist[i]->isvisted= false;//将访问过的节点全部变为未访问，以便下一次广度优先搜索

    }

}


void graph::DFS() {
    stack<int > mystack; //保存顶点的下标
    vertexlist[0]->isvisted= true;
    showvertex(0);

    mystack.push(0);
    int v;
    while (mystack.size()>0)
    {
        v=getadjunivisitedvertex(mystack.top());
        if (v==-1)
        {
            mystack.pop();
        } else
        {
            vertexlist[v]->isvisted= true;
            showvertex(v);
            mystack.push(v);
        }
    }
    cout<<endl;
    for (int i = 0; i <nverts ; i++) {
        vertexlist[i]->isvisted= false;//深度优先再搜索过一遍后还可以再搜索
    }
}

int graph::getadjunivisitedvertex(int v) {

    for (int i = 0; i <nverts ; i++) {
        if((adjmat[v][i]==1)&& (vertexlist[i]->isvisted== false))
        {
            return i;
        }
    }
    return -1;
}


void graph::showvertex(int a) {

    cout<<vertexlist[a]->label<<" ";
}


graph::graph() {
    nverts=0;
    for (int i = 0; i <max_verts ; i++) {
        for (int j = 0; j <max_verts ; j++) {
            adjmat[i][j]=0;
        }
    }
}


void graph::add_edge(int start,int end) {
    adjmat[start][end]=1;
    adjmat[start][end]=1;
}


void graph::printmatrix() {
    for (int i = 0; i <nverts ; i++) {
        for (int j = 0; j <nverts ; j++) {
            cout<<adjmat[i][j]<<" ";
            cout<<endl;
        }
    }
}

void graph::add_vertex(string label) {
    vertexlist[nverts++]=new vertex(label);

}
graph::~graph() {
    for (int i = 0; i <nverts ; i++) {
        delete vertexlist[i];
    }

}

int main() {
    std::cout << "测试自定义的用邻接表实现的图，以及深度优先搜索，广度优先搜索" << std::endl;
    graph mygraph;
    mygraph.add_vertex("lebron");
    mygraph.add_vertex("AD");
    mygraph.add_vertex("kwai");
    mygraph.add_vertex("kuzima");
    mygraph.add_vertex("green");
    mygraph.add_vertex("langduo");
    mygraph.add_edge(0,1);
    mygraph.add_edge(0,2);
    mygraph.add_edge(0,3);
    mygraph.add_edge(1,5);
    mygraph.add_edge(2,4);
    mygraph.BFS();
    cout<<"-------------------"<<endl;
    mygraph.DFS();

    return 0;
}