Question

In my application I have a (unbalanced) tree datastructure. This tree is simply made of “std::list of std::lists” – node holds an arbitrary “list” of sub-nodes. Using this instead of a single list made the rest of the application a lot easier. (The program is about changing moving nodes from one tree to another tree / another part in the tree / to it’s own tree).

Now an obvious task is to find a subtree inside a “tree”. For non-recursive searches it is simple enough:

subtree_iterator find_subtree(const N& n) {         
    auto iter(subtrees.begin());
    auto e(subtrees.end());
    while (iter != e) {
        if ((*iter)->name == n) {
            return iter;
        }
        ++iter;
    }
    return e;
}

Which returns an iterator to the subtree position. The problem however starts when I try to implement a multi-level search. Ie, I wish to search for hello.world.test where the dots mark a new level.

Searching worked alright

subtree_iterator find_subtree(const pTree_type& otree, std::string identify) const {
    pTree_type tree(otree);
    boost::char_separator<char> sep(".");
    boost::tokenizer<boost::char_separator<char> > tokens(identify, sep);
    auto token_iter(tokens.begin());
    auto token_end(tokens.end());

    subtree_iterator subtree_iter;
    for (auto token_iter(tokens.begin()); token_iter != token_end; ++token_iter) {
        std::string subtree_string(*token_iter);
        subtree_iter = tree->find_subtree_if(subtree_string);
        if (subtree_iter == tree->subtree_end()) {
            return otree->subtree_end()
        } else {
            tree = *subtree_iter;
        }
    }
    return subtree_iter;
}

On first glace it seemed to work “correct”, however when I try to use it, it fails. Using it would be like

auto tIn(find_subtree(ProjectTree, "hello.world.test"));
if (tIn != ProjectTree->subtree_end()) {
    //rest
}

however that gives a debug assertion error “list iterators not compatible”. This isn’t too weird: I’m comparing a iterators from different lists to each other. However I could I implement such a thing? My “backup” option would be to return a std::pair<bool,iterator> where the boolean part determines if the tree actually exists. Is there another method, short of making the whole tree single list?

Answer 1

You should not work on iterators internaly. Use nodes instead.

template <typename T>
struct Node {
 T item;
 Node<T>* next;
};

Then encapsulate your Node in an iterator facade like this :

template<typename T>
class iterator {
private:
  Node<T>* node;
public:
  ...
};

Then use a generic invalid node (when node is nullptr) that is returned whenever end() is reached or returned.
Note that what i suggest is a single linked list (not double linked list as the standard one). this is because you can’t go back from an invalid generic end() iterator that point to an invalid null node.
If you don’t use iterator operator–() in your algorithms this should be fine.