图的遍历

#ifndef GRAPH_VISIT_H
#define GRAPH_VISIT_H

#include <queue>
#include<stack>
#include<memory>
#include<limits.h>
#include"../data_struct/data_struct.h"


class graph_visit
{
public:
    /// 广度优先
    static void bfs(const std::shared_ptr<graph_matrix>& graph, std::vector<uint32_t>& out_data)
    {
        std::vector<bool> is_visited(graph->vertex.size(), false);

        for (auto i : graph->vertex)
        {
            //广度遍历未访问过的顶点
            if (!is_visited[i])
            {
                _bfs(graph,i, is_visited, out_data);
            }
        }
    }

private:
    static void _bfs(const std::shared_ptr<graph_matrix>& graph,uint32_t vertex,
                     std::vector<bool>&is_visited, std::vector<uint32_t>& out_data)
    {
        std::queue<uint32_t> que;
        que.emplace(vertex);

        //标记此顶点已经被访问
        is_visited[vertex] = true;
        out_data.emplace_back(vertex);

        //广度遍历顶点的邻接点
        while (!que.empty())
        {
            auto start = que.front();
            que.pop();
            for (auto i : graph->vertex)
            {
                if (!is_visited[i] && graph->matrix[start][i] <INT_MAX)
                {
                    is_visited[i] = true;

                    que.emplace(i);
                    out_data.emplace_back(i);
                }
            }
        }
    }

public:
    /// 深度优先
    static void dfs_r(const std::shared_ptr<graph_matrix>& graph, std::vector<uint32_t>& out_data)
    {
        std::vector<bool> is_visited(graph->vertex.size(), false);

        for (auto i : graph->vertex)
        {
            //广度遍历未访问过的顶点
            if (!is_visited[i])
            {
                _dfs_r(graph, i,  is_visited, out_data);
            }
        }
    }

private:
    static  void _dfs_r(const std::shared_ptr<graph_matrix>& graph,uint32_t vertex,
                      std::vector<bool>&is_visited, std::vector<uint32_t>& out_data)
    {
        out_data.emplace_back(vertex);

        //标记为已访问
        is_visited[vertex] = true;
        for (auto i : graph->vertex)
        {
            if (is_visited[i] == false && graph->matrix[vertex][i] <INT_MAX)
            {
                //深度递归
                _dfs_r(graph, i, is_visited, out_data);
            }
        }
    }

public:
    /// 深度优先非递归
    static void dfs(const std::shared_ptr<graph_matrix>& graph, std::vector<uint32_t>& out_data)
    {
        std::vector<bool> is_visited(graph->vertex.size(), false);

        for (auto i : graph->vertex)
        {
            //广度遍历未访问过的顶点
            if (!is_visited[i])
            {
                _dfs(graph, i, is_visited, out_data);
            }
        }
    }

private:
    static void _dfs(const std::shared_ptr<graph_matrix>& graph,uint32_t vertex,
                            std::vector<bool>&is_visited, std::vector<uint32_t>& out_data)
    {
        out_data.emplace_back(vertex);
        is_visited[vertex] = true;

        std::stack<uint32_t> stack;
        stack.push(vertex);
        while (stack.size() != 0)
        {
            bool is_no_adj = true;//邻接点都已经访问完了 或者没有邻接点了
            auto v = stack.top();
            for (auto i : graph->vertex)
            {
                if (is_visited[i] == false && graph->matrix[v][i] <INT_MAX)
                {
                    out_data.push_back(i);
                    is_visited[i] = true;
                    stack.push(i);
                    is_no_adj = false;
                    break;
                }
            }

            if (is_no_adj)
            {
                stack.pop();
            }
        }
    }
};

#endif // GRAPH_VISIT_H