boost graph

Boost Graph provides tools to work with graphs. Graphas are two-dimensional point clouds with any number of lines between ponts.

Vertices and Edges

1 adjacency_list

#include <boost/graph/adjacency_list.hpp>
#include <iostream>

int main() {
  boost::adjacency_list<> g;

  boost::adjacency_list<>::vertex_descriptor v1 = boost::add_vertex(g);
  boost::adjacency_list<>::vertex_descriptor v2 = boost::add_vertex(g);
  boost::adjacency_list<>::vertex_descriptor v3 = boost::add_vertex(g);
  boost::adjacency_list<>::vertex_descriptor v4 = boost::add_vertex(g);

  std::cout << v1 << ", " << v2 << ", " << v3 << ", " << v4 << std::endl;
  return ;
}

输出  0, 1, 2, 3

boost::adjacency_list is a template that is instantiated with default parameters. boost::add_vertex() adds a point to a graph. boost::add_vertex() returns an object of type boost::adjacency_list::vertex_descriptor. This object represents a newly added point in the graph.

std::vector is the container boost::adjacency_list uses by default to store points. In this case, boost::adjacency_list::vertex_descriptor is a type definition for std::size_t. Because other containers can be used to store points, boost::adjacency_list::vertex_descriptor isn't necessarily always std::size_t.

2. vertices()

#include <boost/graph/adjacency_list.hpp>
#include <utility>
#include <algorithm>
#include <iterator>
#include <iostream>

int main() {
  boost::adjacency_list<> g;

  boost::add_vertex(g);
  boost::add_vertex(g);
  boost::add_vertex(g);
  boost::add_vertex(g);

  std::pair<boost::adjacency_list<>::vertex_iterator, boost::adjacency_list<>::vertex_iterator> vs = boost::vertices(g);

  std::copy(vs.first, vs.second, std::ostream_iterator<boost::adjacency_list<>::vertex_descriptor>{std::cout, "\n"});

  return ;
}

To get all points from a graph, call boost::vertices(). This function returns two iterators of type boost::adjacency_list::vertex_iterator, which refer to the beginning and ending points.

3. edges()

#include <boost/graph/adjacency_list.hpp>
#include <utility>
#include <algorithm>
#include <iterator>
#include <iostream>

int main() {
  boost::adjacency_list<> g;

  boost::adjacency_list<>::vertex_descriptor v1 = boost::add_vertex(g);
  boost::adjacency_list<>::vertex_descriptor v2 = boost::add_vertex(g);
  boost::add_vertex(g);
  boost::add_vertex(g);

  std::pair<boost::adjacency_list<>::edge_descriptor, bool> p = boost::add_edge(v1, v2, g);
  std::cout.setf(std::ios::boolalpha);
  std::cout << p.second << std::endl;

  p = boost::add_edge(v1, v2, g);
  std::cout << p.second << std::endl;

  p = boost::add_edge(v2, v2, g);
  std::cout << p.second << std::endl;

  std::pair<boost::adjacency_list<>::edge_iterator, boost::adjacency_list<>::edge_iterator> es = boost::edges(g);

  std::copy(es.first, es.second, std::ostream_iterator<boost::adjacency_list<>::edge_descriptor>{std::cout, "\n"});

  return ;
}

输出：

true

true

true

(0,1)

(0,1)

(1,0)

You call boost::add_edge() to connect two points in a graph. You have to pass the points and the graph as parameters. boost::add_edge() returns a std::pair. first provides access to the line. second is a bool variable that indicates whether the line was successfully added.

boost::edges() provides access to all lines in a graph. boost::edges() returns two iterators that refer to the beginning and ending lines. lines start at the first point, one at the second. The direction of the lines depends on the order of the parameters passed to boost::add_edge().

As you see, you can have multiple lines between the same two points.

4. boost::adjacency_list with selectors

#include <boost/graph/adjacency_list.hpp>
#include <utility>
#include <algorithm>
#include <iterator>
#include <iostream>

int main() {
  typedef boost::adjacency_list<boost::setS, boost::vecS, boost::undirectedS> graph;
  graph g;

  boost::adjacency_list<>::vertex_descriptor v1 = boost::add_vertex(g);
  boost::adjacency_list<>::vertex_descriptor v2 = boost::add_vertex(g);
  boost::add_vertex(g);
  boost::add_vertex(g);

  std::pair<boost::adjacency_list<>::edge_descriptor, bool> p = boost::add_edge(v1, v2, g);
  std::cout.setf(std::ios::boolalpha);
  std::cout << p.second << std::endl;

  p = boost::add_edge(v1, v2, g);
  std::cout << p.second << std::endl;

  p = boost::add_edge(v2, v2, g);
  std::cout << p.second << std::endl;

  std::pair<boost::adjacency_list<>::edge_iterator, boost::adjacency_list<>::edge_iterator> es = boost::edges(g);

  std::copy(es.first, es.second, std::ostream_iterator<boost::adjacency_list<>::edge_descriptor>{std::cout, "\n"});

  return ;
}

By default, boost::adjacency_list uses std::vector for points and lines. By passing boost::setS as the first template parameter, std::set is selected as the container for lines.

The second template parameter tells boost::adjacency_list which class should be used for points.

The third template parameter determines whether lines are directed or undirected. The default is boost::directedS, which means all lines are directed and can be drawn as arrows. Lines can only be crossed in one direction.

Boost.Graph offers more selectors, including boost::listS, boost::mapS, and boost::hash_setS. boost::bidirectionalS can be used to make lines bidirectional.

5. creating indexes automatically with boost::add_edge()

#include <boost/graph/adjacency_list.hpp>
#include <tuple>
#include <algorithm>
#include <iterator>
#include <iostream>

int main() {
  typedef boost::adjacency_list<boost::setS, boost::vecS, boost::undirectedS> graph;
  graph g;

  enum { topLeft, topRight, bottomRight, bottomLeft };

  boost::add_edge(topLeft, topRight, g);
  boost::add_edge(topRight, bottomRight, g);
  boost::add_edge(bottomRight, bottomLeft, g);
  boost::add_edge(bottomLeft, topLeft, g);

  graph::edge_iterator it, end;
  std::tie(it, end) = boost::edges(g);
  std::copy(it, end, std::ostream_iterator<graph::edge_descriptor>{std::cout, "\n"});

  return ;
}

It is possible to define a graph without calling boost::add_vertex(). Boost.Graph adds missing points to a graph automatically if the points passed to boost::add_edge() don't exist.

Containers

except boost::adjacency_list, there are two other graph containers provided by Boost.Graph: boost::adjacency_matrix, boost::compressed_sparse_row_graph.

1. boost::adjacency_matrix

#include <boost/graph/adjacency_matrix.hpp>
#include <array>
#include <utility>

int main() {
  enum { topLeft, topRight, bottomRight, bottomLeft };

  std::array<std::pair<int, int>, > edges{{
    std::make_pair(topLeft, topRight);
    std::make_pair(topRight, bottomRight);
    std::make_pair(bottomRight, bottomLeft);
    std::make_pair(bottomLeft, topLeft);
  }};

  typedef boost::adjacency_matrix<boost::undirectedS> graph;
  graph g{edges.beign(), edges.end(), };

  return ;
}

The two template parameters that pass selectors don't exist with boost::adjacency_matrix. With boost::adjacency_matrix, no selectors, such as boost::vecS and boost::setS, are used. boost::adjacency_matrix stores the graph in a matrix, and the internal structure is hardcoded. You can think of the matrix as a two-dimensional table: the table is a square with as many rows and columuns as the graph has points. The internal structure of boost::adjacency_matrix makes it possible to add and remove lines quickly. However, memory consumption is highter. The rule of thumb is to use boost::adjacency_list when there are relatively few lines compared to points. The more lines there are, the more it makes sense to use boost::adjacency_matrix.

2. boost::compressed_sparse_row_graph

#include <boost/graph/adjacency_matrix.hpp>
#include <array>
#include <utility>

int main() {
  enum { topLeft, topRight, bottomRight, bottomLeft };

  std::array<std::pair<int, int>, > edges{{
    std::make_pair(topLeft, topRight);
    std::make_pair(topRight, bottomRight);
    std::make_pair(bottomRight, bottomLeft);
    std::make_pair(bottomLeft, topLeft);
  }};

  typedef boost::compressed_sparse_row_graph<boost::bidirectionalS> graph;
  graph g{boost::edges_are_unsorted_multi_pass, edges.beign(), edges.end(), };

  return ;
}

boost::compressed_sparse_row_graph can't be changed with. Once the graph has been created, points and lines can't be added or removed. Thus, boost::compressed_sparse_rwo_graph makes only sense when using an immutable graph. only supports directed lines and is low memory consumption.