基於鄰接矩陣實現的圖,以及圖的深度優先和廣度優先

#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;
}