C++ Grafo::insert_node方法代码示例

void build_test_graph(Grafo & g)
{
  g.insert_node("A");
  g.insert_node("B");
  g.insert_node("C");
  g.insert_node("D");
  g.insert_node("E");
  g.insert_node("F");
  g.insert_node("G");
  g.insert_node("H");
  g.insert_node("I");

  insertar_arco(g, "A", "B", 2);
  insertar_arco(g, "A", "F", 5);
  insertar_arco(g, "B", "F", 1);
  insertar_arco(g, "B", "D", 3);
  insertar_arco(g, "C", "A", 1);  
  insertar_arco(g, "C", "E", 4);  
  insertar_arco(g, "F", "D", -2);
  insertar_arco(g, "F", "C", -1);
  insertar_arco(g, "F", "E", 2);
  insertar_arco(g, "D", "F", 2);
  insertar_arco(g, "D", "H", 4);
  insertar_arco(g, "E", "G", 2);
  insertar_arco(g, "E", "I", -2);
  insertar_arco(g, "G", "D", 3);
  insertar_arco(g, "G", "F", -1);
  insertar_arco(g, "G", "H", 2);
  insertar_arco(g, "H", "D", -2);
  insertar_arco(g, "H", "G", -1);
  insertar_arco(g, "I", "G", 4);
  insertar_arco(g, "I", "H", 3);

}

void crear_arco(Grafo & g, int isrc, int itgt)
{
  Grafo::Node * src = g.search_node(isrc);
  if (src == NULL)
    src = g.insert_node(isrc);

  Grafo::Node * tgt = g.search_node(itgt);
  if (tgt == NULL)
    tgt = g.insert_node(itgt);

  if (search_arc<Grafo>(g, src, tgt) != NULL)
    throw std::invalid_argument("Duplicated arc");

  g.insert_arc(src, tgt);
}

void insertar_arco(Grafo &        grafo, 
		   const string & src_name, 
		   const string & tgt_name)
{
  Grafo::Node * n1 = grafo.search_node(Nodo(src_name));

  if (n1 == NULL)
    n1 = grafo.insert_node(src_name);

  Grafo::Node * n2 = grafo.search_node(Nodo(tgt_name));

  if (n2 == NULL)
    n2 = grafo.insert_node(tgt_name);

  grafo.insert_arc(n1, n2);
}

void build_test_graph_1(Grafo & g)
{
  g.insert_node(Nodo("E"));

  insertar_arco(g, "A", "B");
  insertar_arco(g, "A", "D");
  insertar_arco(g, "B", "C");
  insertar_arco(g, "C", "A");
  insertar_arco(g, "D", "E");
  insertar_arco(g, "E", "B");
  insertar_arco(g, "E", "D");

  insertar_arco(g, "E", "G");

  insertar_arco(g, "G", "F");
  insertar_arco(g, "F", "G");

  insertar_arco(g, "E", "H");

  insertar_arco(g, "H", "I");

  insertar_arco(g, "I", "J");
  insertar_arco(g, "J", "K");
  insertar_arco(g, "K", "I");
}

void insertar_arco(Grafo &       grafo, 
		  const string & src_name, 
		  const string & tgt_name,
		  const double & distancia)
{
  Grafo::Node * n1 = grafo.find_node(Nodo(src_name));

  if (n1 == NULL)
    n1 = grafo.insert_node(src_name);

  Grafo::Node * n2 = grafo.find_node(Nodo(tgt_name));

  if (n2 == NULL)
    n2 = grafo.insert_node(tgt_name);

  grafo.insert_arc(n1, n2, Arco(distancia));
}

Grafo * build_graph()
{
  Grafo * g = new Grafo;

  for (int i = 'A'; i <= 'P'; ++i)
    g->insert_node(new Grafo::Node(i));

  insertar_arco(g, "A", "B", 3);
  //  insertar_arco(g, "B", "A", 3);
  insertar_arco(g, "B", "C", 4);
  insertar_arco(g, "C", "D", 3);
  insertar_arco(g, "D", "E", 4);
  insertar_arco(g, "E", "K", 2);
  insertar_arco(g, "K", "P", 7);
  insertar_arco(g, "P", "J", 1);
  insertar_arco(g, "J", "K", 4);
  insertar_arco(g, "K", "D", 5);
  insertar_arco(g, "D", "J", 2);
  insertar_arco(g, "J", "I", 2);
  //  insertar_arco(g, "I", "J", 2);
  insertar_arco(g, "I", "D", 1);
  insertar_arco(g, "I", "C", 2);
  insertar_arco(g, "I", "H", 2);
  insertar_arco(g, "H", "C", 3);
  insertar_arco(g, "H", "B", 7);
  insertar_arco(g, "B", "G", 1);
  insertar_arco(g, "B", "M", 15);
  //  insertar_arco(g, "M", "B", 3);
  insertar_arco(g, "M", "G", 10);
  insertar_arco(g, "G", "A", 4);
  insertar_arco(g, "A", "F", 9);
  insertar_arco(g, "F", "G", 5);
  insertar_arco(g, "F", "L", 10);
  insertar_arco(g, "F", "M", 12);
  insertar_arco(g, "H", "M", 8);
  insertar_arco(g, "L", "M", 4);
  insertar_arco(g, "M", "N", 2);
  insertar_arco(g, "N", "H", 3);
  insertar_arco(g, "N", "I", 1);
  insertar_arco(g, "N", "O", 3);
  insertar_arco(g, "O", "I", 3);
  insertar_arco(g, "O", "J", 1);
  insertar_arco(g, "O", "P", 6);

  return g;    
}

void construir_grafo(Grafo & g)
{
  Grafo::Node * n1 = g.insert_node(_Node(1));
  Grafo::Node * n2 = g.insert_node(_Node(2));
  Grafo::Node * n3 = g.insert_node(_Node(3));
  Grafo::Node * n4 = g.insert_node(_Node(4));
  Grafo::Node * n5 = g.insert_node(_Node(5));
  Grafo::Node * n6 = g.insert_node(_Node(6));
  Grafo::Node * n7 = g.insert_node(_Node(7));
  Grafo::Node * n8 = g.insert_node(_Node(8));
  Grafo::Node * n9 = g.insert_node(_Node(9));
  Grafo::Node * n10 = g.insert_node(_Node(10));
  Grafo::Node * n11 = g.insert_node(_Node(11));
  Grafo::Node * n12 = g.insert_node(_Node(12));
  Grafo::Node * n13 = g.insert_node(_Node(13));
  Grafo::Node * n14 = g.insert_node(_Node(14));
  Grafo::Node * n15 = g.insert_node(_Node(15));
  Grafo::Node * n16 = g.insert_node(_Node(16));
  Grafo::Node * n17 = g.insert_node(_Node(17));
  Grafo::Node * n18 = g.insert_node(_Node(18));
  Grafo::Node * n19 = g.insert_node(_Node(19));
  Grafo::Node * n20 = g.insert_node(_Node(20));
  Grafo::Node * n21 = g.insert_node(_Node(21));
  Grafo::Node * n22 = g.insert_node(_Node(22));
  Grafo::Node * n23 = g.insert_node(_Node(23));
  Grafo::Node * n24 = g.insert_node(_Node(24));
  Grafo::Node * n25 = g.insert_node(_Node(25));
  Grafo::Node * n26 = g.insert_node(_Node(26));
  Grafo::Node * n27 = g.insert_node(_Node(27));
  Grafo::Node * n28 = g.insert_node(_Node(28));

  insertar_arco(g, n1, n2);
  insertar_arco(g, n1, n3);
  insertar_arco(g, n1, n7);
  insertar_arco(g, n1, n14);
  insertar_arco(g, n1, n21);
  insertar_arco(g, n1, n22);

  insertar_arco(g, n7, n8);
  insertar_arco(g, n7, n12);
  insertar_arco(g, n7, n10);
  insertar_arco(g, n8, n10);
  insertar_arco(g, n8, n9);
  insertar_arco(g, n9, n10);
  insertar_arco(g, n9, n13);
  insertar_arco(g, n10, n11);
  insertar_arco(g, n10, n12);
  insertar_arco(g, n10, n13);
  insertar_arco(g, n11, n13);
  insertar_arco(g, n11, n12);

  insertar_arco(g, n2, n5);
  insertar_arco(g, n2, n4);
  insertar_arco(g, n5, n4);
  insertar_arco(g, n5, n6);
  insertar_arco(g, n6, n4);
  insertar_arco(g, n6, n3);
  insertar_arco(g, n3, n4);

  insertar_arco(g, n14, n15);
  insertar_arco(g, n14, n17);
  insertar_arco(g, n14, n16);
  insertar_arco(g, n17, n20);
  insertar_arco(g, n20, n19);
  insertar_arco(g, n19, n16);
  insertar_arco(g, n19, n18);
  insertar_arco(g, n18, n16);
  insertar_arco(g, n18, n15);

  insertar_arco(g, n21, n23);
  insertar_arco(g, n21, n22);
  insertar_arco(g, n22, n23);
  insertar_arco(g, n23, n28);
  insertar_arco(g, n23, n24);
  insertar_arco(g, n28, n24);
  insertar_arco(g, n24, n27);
  insertar_arco(g, n24, n25);
  insertar_arco(g, n28, n27);
  insertar_arco(g, n27, n25);
  insertar_arco(g, n25, n26);
  insertar_arco(g, n25, n27);
  insertar_arco(g, n26, n27);
}

void crear_grafo(Grafo & g)
{
  g.insert_node(1);
  g.insert_node(2);
  g.insert_node(3);
  g.insert_node(4);
  g.insert_node(5);
  g.insert_node(6);
  g.insert_node(7);
  g.insert_node(8);
  g.insert_node(9);
  g.insert_node(10);
  g.insert_node(11);
  g.insert_node(12);
  g.insert_node(13);
  g.insert_node(14);
  g.insert_node(15);
  g.insert_node(16);
  g.insert_node(17);
  g.insert_node(18);
  g.insert_node(19);
  g.insert_node(20);
  g.insert_node(21);
  g.insert_node(22);
  g.insert_node(23);
  g.insert_node(24);
  g.insert_node(25);
  g.insert_node(26);
  g.insert_node(27);

  crear_arco(g, 17, 6);
  crear_arco(g, 17, 12);
  crear_arco(g, 17, 18);
  crear_arco(g, 17, 23);
  crear_arco(g, 23, 12);
  crear_arco(g, 23, 18);
  crear_arco(g, 23, 24);
  crear_arco(g, 12, 6);
  crear_arco(g, 12, 7);
  crear_arco(g, 18, 12);
  crear_arco(g, 24, 18);
  crear_arco(g, 24, 19);
  crear_arco(g, 24, 25);
  crear_arco(g, 25, 18);
  crear_arco(g, 25, 12);
  crear_arco(g, 25, 19);
  crear_arco(g, 26, 15);
  crear_arco(g, 19, 12);
  crear_arco(g, 19, 13);
  crear_arco(g, 13, 12);
  crear_arco(g, 13, 6);
  crear_arco(g, 13, 7);
  crear_arco(g, 7, 6);
  crear_arco(g, 7, 1);
  crear_arco(g, 13, 8);
  crear_arco(g, 8, 7);
  crear_arco(g, 8, 1);
  crear_arco(g, 8,2 );
  crear_arco(g, 8, 3);
  crear_arco(g, 8, 9);
  crear_arco(g, 9, 4);
  crear_arco(g, 14, 13);
  crear_arco(g, 14, 8);
  crear_arco(g, 14, 3);
  crear_arco(g, 14, 19);
  crear_arco(g, 14, 25);
  crear_arco(g, 14, 20);
  crear_arco(g, 14, 15);
  crear_arco(g, 14, 9);
  crear_arco(g, 9, 3);
  crear_arco(g, 15, 9);
  crear_arco(g, 20, 26 );
  crear_arco(g, 20, 25);
  crear_arco(g, 20, 27);
  crear_arco(g, 20, 21);
  crear_arco(g, 20, 15);
  crear_arco(g, 15, 21);
  crear_arco(g, 21, 27);
  crear_arco(g, 21, 16);
  crear_arco(g, 21, 22);
  crear_arco(g, 15, 16);
  crear_arco(g, 15, 10);
  crear_arco(g, 10, 9);
  crear_arco(g, 10, 4);
  crear_arco(g, 10, 5);
  crear_arco(g, 10, 11);
  crear_arco(g, 10, 16);
  crear_arco(g, 16, 11);
  crear_arco(g, 16, 22);
  crear_arco(g, 16, 27);
  crear_arco(g, 27, 22);
  crear_arco(g, 22, 11);
  crear_arco(g, 11, 5);
  crear_arco(g, 5, 4);
  crear_arco(g, 5, 9);
  crear_arco(g, 4, 3);
  crear_arco(g, 3, 2);
  crear_arco(g, 2, 1);
  crear_arco(g, 2, 13);
  crear_arco(g, 2, 15);
//.........这里部分代码省略.........