在现有数据结构上使用BGL算法需要什么(边和顶点作为矢量<对象*>)？

vector<myVertex *> my_vertices;
vector<myEdge *> my_edges;

adjacency_list<OutEdgeListS, VertexListS, DirectedS,
             VertexProperty, EdgeProperty, GraphProperty, EdgeListS>

MyGraph g(const& my_edges,const& my_vertices,
  undirected_tag, some_color, someweights, allow_parallel_edges_tag);

图形概念的文档很方便：https：//www.boost.org/doc/libs/1_70_0_0/libs/graph/graph/doc/graph/doc/graph_coneptss.html

所以 - 您从未告诉过我们打算使用哪种算法。

所以让我选一个示例：bfs。文档说这需要：

有向或无向图。图类型必须是顶点列表图和发射率图的模型。

查看您先前存在的数据结构，看起来您只能轻松覆盖顶点列表用例。

边缘更多地作为边缘列表实现。没有运行时或存储开销的情况下，不可能从边缘列表中模拟入击图(这是数学，与库或代码质量无关(。

实际上，您很可能会省略与问题相关的已存在的数据结构的部分，因为大多数算法在Just Pertex Edge Lists上都非常优势。

。

实际上，我想您的边缘列表可能像经典的邻接列表一样组织(例如，通过源顶点订购，因此您可以通过source dertex进行O(log(log(n((查找(。

对于下面的示例我假设是这种情况。请记住，我们只是接近从发病率图概念中保证的复杂性：

复杂性保证

source()，target()和out_edges()功能都必须是恒定的时间。out_degree()函数必须在外边的数量中线性。

要真正满足这些要求，您需要专用于每个顶点的外艇

所以，让我们去吧：

嘲笑你的library

namespace YourLibrary {
    struct myVertex {
    };
    struct myEdge {
        myVertex* _s = nullptr;
        myVertex* _t = nullptr;
        myVertex* source() const { return _s; }
        myVertex* target() const { return _t; }
    };
    using Vertices = std::vector<myVertex *>;
    using Edges = std::vector<myEdge *>;
}

实现图形概念

您想继续引用预先存在的数据结构：

namespace Glue {
    struct MyGraph {
        struct EdgeOrder {
            template <typename A, typename B>
                bool operator()(A const* a, B const* b) const { return source(a) < source(b); }
            private:
            static auto source(YourLibrary::myVertex const* v) { return v; }
            static auto source(YourLibrary::myEdge const* e) { return e->source(); }
        };
        using Vertices = YourLibrary::Vertices;
        using Edges = YourLibrary::Edges;
        Vertices& _vertices;
        Edges& _edges;
        MyGraph(Vertices& vv, Edges& ee) : _vertices(vv), _edges(ee)  { }
    };
}

现在，我将按照概念的列表列出所需特质类型的列表：

namespace boost {
    template <> struct graph_traits<Glue::MyGraph> {
        // Due to Graph concept
        using vertex_descriptor      = YourLibrary::myVertex*;
        using edge_descriptor        = YourLibrary::myEdge*;
        using directed_category      = directed_tag;
        using edge_parallel_category = allow_parallel_edge_tag;
        static vertex_descriptor null_vertex() { return nullptr; }
        // Due to Vertex List concept
        struct traversal_category : vertex_list_graph_tag, incidence_graph_tag { };
        using vertex_iterator        = Glue::MyGraph::Vertices::const_iterator;
        using vertices_size_type     = std::size_t;
        // Due to Incidence Graph concept
        using out_edge_iterator = Glue::MyGraph::Edges::const_iterator;
        using degree_size_type = std::size_t;
    };
}

最后重新打开了名称空间，以便ADL可以找到满足"有效表达式"标准所需的这些功能：

namespace Glue {
    // Due to Vertex List concept
    auto vertices(MyGraph const& g) {
        return std::make_pair(g._vertices.begin(), g._vertices.end());
    }
    std::size_t num_vertices(MyGraph const& g) {
        return g._vertices.size();
    }
    // Due to Incidence Graph concept
    auto source(YourLibrary::myEdge const* e, MyGraph const& g) {
        return e->source();
    }
    auto target(YourLibrary::myEdge const* e, MyGraph const& g) {
        return e->target();
    }
    auto out_edges(YourLibrary::myVertex const* v, MyGraph const& g) {
        return std::equal_range(g._edges.begin(), g._edges.end(), v, MyGraph::EdgeOrder{});;
    }
    std::size_t out_degree(YourLibrary::myVertex const* v, MyGraph const& g) {
        auto oee = std::equal_range(g._edges.begin(), g._edges.end(), v, MyGraph::EdgeOrder{});
        return std::distance(oee.first, oee.second);
    }
}

这将大致在功能上等同于aidjencency_list，for setS用于顶点容器。

请参阅 Live on Coliru

运行BFS

另外所需的一切都是算法的参数。您需要颜色映射和顶点索引图。这是完全正常的，如果您有例如adjacency_list<vecS, listS, directedS>。

我将在MyGraph包装器中隐藏索引图并揭露颜色地图，以便您选择您的偏好：

活在coliru

#include <boost/graph/adjacency_list.hpp>
#include <boost/graph/breadth_first_search.hpp>
#include <boost/container/flat_map.hpp>
#include <algorithm>
namespace YourLibrary {
    struct myVertex {
    };
    struct myEdge {
        myVertex* _s = nullptr;
        myVertex* _t = nullptr;
        myVertex* source() const { return _s; }
        myVertex* target() const { return _t; }
    };
    using Vertices = std::vector<myVertex *>;
    using Edges = std::vector<myEdge *>;
}
namespace Glue {
    struct MyGraph {
        struct EdgeOrder {
            template <typename A, typename B>
                bool operator()(A const* a, B const* b) const { return source(a) < source(b); }
            private:
            static auto source(YourLibrary::myVertex const* v) { return v; }
            static auto source(YourLibrary::myEdge const* e) { return e->source(); }
        };
        using Vertices = YourLibrary::Vertices;
        using Edges = YourLibrary::Edges;
        using Index = boost::container::flat_map<Vertices::value_type, std::size_t>;
        Vertices& _vertices;
        Edges& _edges;
        Index _index;
        MyGraph(Vertices& vv, Edges& ee) : _vertices(vv), _edges(ee)  {
            _index.reserve(vv.size());
            std::size_t i = 0;
            for(auto v : vv) { _index[v] = i++; }
        }
    };
}
namespace boost {
    template <> struct graph_traits<Glue::MyGraph> {
        // Due to Graph concept
        using vertex_descriptor      = YourLibrary::myVertex*;
        using edge_descriptor        = YourLibrary::myEdge*;
        using directed_category      = directed_tag;
        using edge_parallel_category = allow_parallel_edge_tag;
        static vertex_descriptor null_vertex() { return nullptr; }
        // Due to Vertex List concept
        struct traversal_category : vertex_list_graph_tag, incidence_graph_tag { };
        using vertex_iterator        = Glue::MyGraph::Vertices::const_iterator;
        using vertices_size_type     = std::size_t;
        // Due to Incidence Graph concept
        using out_edge_iterator = Glue::MyGraph::Edges::const_iterator;
        using degree_size_type = std::size_t;
    };
}
namespace Glue {
    // Due to Vertex List concept
    auto vertices(MyGraph const& g) {
        return std::make_pair(g._vertices.begin(), g._vertices.end());
    }
    std::size_t num_vertices(MyGraph const& g) {
        return g._vertices.size();
    }
    // Due to Incidence Graph concept
    auto source(YourLibrary::myEdge const* e, MyGraph const& g) {
        return e->source();
    }
    auto target(YourLibrary::myEdge const* e, MyGraph const& g) {
        return e->target();
    }
    auto out_edges(YourLibrary::myVertex const* v, MyGraph const& g) {
        return std::equal_range(g._edges.begin(), g._edges.end(), v, MyGraph::EdgeOrder{});;
    }
    std::size_t out_degree(YourLibrary::myVertex const* v, MyGraph const& g) {
        auto oee = std::equal_range(g._edges.begin(), g._edges.end(), v, MyGraph::EdgeOrder{});
        return std::distance(oee.first, oee.second);
    }
    // Due to BFD requiring the index_map
    auto get(boost::vertex_index_t, MyGraph const& g) {
        return boost::make_assoc_property_map(g._index);
    }
}
int main() {
    // I hate manual memory management, so let's own some objects
    auto a = std::make_unique<YourLibrary::myVertex>();
    auto b = std::make_unique<YourLibrary::myVertex>();
    auto c = std::make_unique<YourLibrary::myVertex>();
    auto ab = std::make_unique<YourLibrary::myEdge>(YourLibrary::myEdge{a.get(), b.get()});
    auto bc = std::make_unique<YourLibrary::myEdge>(YourLibrary::myEdge{b.get(), c.get()});
    // These were given in your question:
    YourLibrary::Vertices vv { a.get(), b.get(), c.get() };
    YourLibrary::Edges ee { ab.get(), bc.get() };
    // this is the glue required to fulfill the BGL concepts:
    Glue::MyGraph g(vv, ee);
    // this is showing that you can now BFS on it
    using V = boost::graph_traits<Glue::MyGraph>::vertex_descriptor;
    V start_vertex = a.get();
    std::map<V, boost::default_color_type> color_data;
    boost::breadth_first_search(g, start_vertex,
            boost::visitor(boost::default_bfs_visitor{})
            .color_map(boost::make_assoc_property_map(color_data)));
}

结论

算法有要求，只要您满足它们，就可以使用所需的任何数据结构。

在这种情况下，您可能想真正确定所做的假设，然后将其添加到MyGraph构造函数：

assert(std::is_sorted(_edges.begin(), _edges.end(), EdgeOrder{}));