图的两种遍历方式

图的遍历有两种：深度优先和广度优先。本文中，深度优先使用递归实现，每次递归找到第一个与当前结点相连且未输出过的结点继续往下递归，直至所有结点都已输出。广度优先将开始结点的所有邻接结点全部压入栈，当栈不为空时一直循环将栈首的结点的所有相邻结点压入栈。

具体代码实现如下：

//邻接链表
class Graph {
private:
    //n: number of nodes
    int n;
    vector<int> *edges;
    bool *visited;
public:
    Graph(int input_n) {
        n = input_n;
        edges = new vector<int>[n];
        visited=new bool[n];
        //size of bool=1
        memset(visited,0,n);
    }
    ~Graph() {
        delete[] edges;
        delete[] visited;
    }
    //no directions
    void insert(int x, int y) {
        edges[x].push_back(y);
        edges[y].push_back(x);
    }

    //visited will be changed after one traversal
    //so need to reset for new operations
    void reset_visited(){
        memset(visited,0,n);
    }

    void dfs(int vertex) {
        cout<<vertex<<endl;
        visited[vertex]=true;
        for(int adj_vertex: edges[vertex]){
            if(!visited[adj_vertex]){
                dfs(adj_vertex);
            }
        }
    }

    void bfs(int start_vertex) {
        queue<int> bfs_queue;
        bfs_queue.push(start_vertex);
        visited[start_vertex]=true;
        while(!bfs_queue.empty()){
            int vertex=bfs_queue.front();
            cout<<vertex<<endl;
            bfs_queue.pop();
            for(int adj_vertex: edges[vertex]){
                //if it has not been put into the queue yet
                if(!visited[adj_vertex]){
                    visited[adj_vertex]=true;
                    bfs_queue.push(adj_vertex);
                }
            }
        }
    }
};




//邻接矩阵
class Graph {
private:
    //指向邻接矩阵
    int **mat;
    //n为顶点个数, 注意这里顶点是从0开始编号的
    int n;
    bool *visited;
public:
    Graph(int input_n) {
        n = input_n;
        mat = new int *[n];
        for (int i = 0; i < n; ++i) {
            mat[i] = new int[n];
            memset(mat[i], 0, sizeof(int) * n);
        }
        visited=new bool[input_n];
        memset(visited,0,input_n);
    }
    ~Graph() {
        for (int i = 0; i< n; ++i) {
            delete[] mat[i];
        }
        delete[] mat;
        delete[] visited;
    }
    //flag=0为有向图, flag=1为无向图
    void insert(int x,int y, int flag){
        mat[x][y]=1;
        if(flag==1){
            mat[y][x]=1;
        }
    }
    void output() {
        for(int i=0;i<n;i++){
            for(int j=0;j<n;j++){
                cout<<mat[i][j]<<" ";
            }
            cout<<endl;
        }
    }
    
    void reset_visited(){
        memset(visited,0,n);
    }
    
    void dfs(int cur_vertex){
        cout<<cur_vertex<<endl;
        visited[cur_vertex]=true;
        for(int adj_ver=0;adj_ver<n;adj_ver++){
            if((!visited[adj_ver]) && mat[cur_vertex][adj_ver]==1){
                dfs(adj_ver);
            }
        }
    }
    
    
    void bfs(int start_vertex){
        queue<int> bfs_queue;
        bfs_queue.push(start_vertex);
        visited[start_vertex]=true;
        while(!bfs_queue.empty()){
            int cur_ver=bfs_queue.front();
            bfs_queue.pop();
            cout<<cur_ver<<endl;
            for(int adj_ver=0; adj_ver<n; adj_ver++){
                if((!visited[adj_ver]) && mat[cur_ver][adj_ver]==1){
                    bfs_queue.push(adj_ver);
                    visited[adj_ver]=true;
                }
            }
        }
    }
};