Bridesearch implementation with c++ - c++

Question

std::string Breitensuche ( std::array < std::list<std::array<int, 2>>, 3> list, int von, int zu ,std::string weg)
{
std::list<int> markiert;
for ( auto &b : list.at(von) )
{
if ( b.at ( 0 ) == zu )
return
weg += std::to_string ( b.at ( 0 ) );
else
markiert.push_back ( b.at ( 0 ) );
}
for ( auto &a : markiert )
{
Breitensuche ( list, a.at ( 0 ), zu );
}
return "";
}
int main ( )
{
std::array < std::list<std::array<int, 2>>, 3> Adjazenzliste { { { { { 0, 5 } } }, { { { 0, 5 } }, { { 2, 7 } } }, { { { 1, 4 } } } } };
std::cout << Breitensuche ( Adjazenzliste, 1, 2 ,"");
system ( "Pause" );
}
I was trying to implement bridesearch of graphs with c++ with adjazenzlists.
the first part of the arrays which are hold in the list which are hold in arrays are the name of the node to which the startnode of the list has a connection and the second is the weight of the connection.
So basicly in this initalization there are 3 lists
0 -> 1
1 -> 0 -> 2
2 -> 1
In the function above a tried that first of all every element of the list gets checked and if its not the searched node it gets marked and after this the function gets called for every marked spot again and again, if its found it returns the nodename.
I am encountering problems with not getting into depthsearch cause if i do it recursive it will allways first check it deep and then do the next...
Furthemore i have problems to safe the "path" if its found and return it...
I hope you understand what i mean, sorry for my bad english

Answer 1

The Breadth-first search algorithm described on Wikipedia doesn't require recursiveness. The pseudocode talks about a queue q for the ordering and a set V (capital V) to make sure duplicate values get matched only once (which I have left out in the code below):
#include <iostream>
#include <string>
#include <vector>
#include <queue>
using namespace std;
template<class T>
struct tree_item {
T value;
vector<tree_item<T>> children;
tree_item(T value) : value(value) {}
};
// constructs animated gif http://en.wikipedia.org/wiki/Breadth-first_search
tree_item<string> build_tree() {
tree_item<string> a("a"), b("b"), c("c"), d("d"), e("e"), f("f"), g("g"), h("h");
e.children = { h };
b.children = {d, e};
c.children = {f, g};
a.children = {b, c};
return a;
}
// implements "Algorithm" -> "Pseudocode" http://en.wikipedia.org/wiki/Breadth-first_search
template<class T>
bool find_breadth_first(const tree_item<T>& v, function<bool(const T&)> matcher, tree_item<T>& found_item) {
queue<const tree_item<T>*> q; // step 2
q.push(&v); // step 5
while(!q.empty()) { // step 6
auto t = q.front(); q.pop(); // step 7
cout << "currently visiting " << t->value << endl;
if(matcher(t->value)) { // step 8
cout << t->value << " is a match " << endl;
found_item = *t; return true; // step 9
}
for(auto& u : t->children) // step 11
q.push(&u); // step 15
}
return false; // step 19
}
int main() {
auto root = build_tree();
tree_item<string> match("no match");
auto matcher = [&](auto candidate) {
return candidate == "g";
};
auto found = find_breadth_first<string>(root, matcher, match);
if(found)
cout << "found: " << match.value << endl;
else
cout << "not found" << endl;
}
Output:
currently visiting a
currently visiting b
currently visiting c
currently visiting d
currently visiting e
currently visiting f
currently visiting g
g is a match
found: g