深度优先与广度优先搜索算法简单复习

测试有向图，代码表示使用邻接矩阵。

                                       

算法代码：

#include<Windows.h>
#include<stdio.h>
#include<stdlib.h>
#include<iostream>

/* stl */
#include<vector>
#include<algorithm>
#include<queue>
#include<deque>
#include<stack>
#include<list>
#include<map>

#include<unordered_map>
#include<unordered_set>

using namespace std;

// 使用邻接矩阵广度优先遍历
void my_bfs(const vector<vector<int>>& g, int start_)
{
        queue<int> q_;
        std::unordered_set<int> check_;

        q_.push(start_);
        check_.insert(start_);

        while (q_.size()) {

                int n = q_.front();
                cout << n << " ";

                for (int i = 0; i < g.size(); i++) {

                        if (g[n][i] > 0 && check_.find(i) == check_.end()) {

                                q_.push(i);
                                check_.insert(i);
                        }
                }
                q_.pop();
        }
}

// 使用邻接矩阵的深度优先遍历

std::unordered_set<int> check_;

void my_dfs(const vector<vector<int>>& g, int start_)
{
        cout << start_ << " ";
        check_.insert(start_);

        for (int i = 0; i < g.size(); i++) {

                if (g[start_][i] > 0 && check_.find(i) == check_.end())
                        my_dfs(g, i);
        }
}

int main(int argc, char* argv[])
{

        vector<vector<int>> g_{ {1,1,1,0,0},
                                {0,1,0,1,1},
                                {0,0,1,0,0},
                                {0,0,0,1,1},
                                {0,0,1,0,1} 
                              };

        //my_bfs(g_, 3);
        my_dfs(g_, 4);
	return 0;
}