Question

这可能需要一些解释，所以请光临我。我有一个类“Class”，它有一个成员std :: list，我想在列表/树中搜索一个项目，特别是一个具有特定名称的项目。我班的基本代表如下。


#include <list>
#include <string>
class Class {
    std::string _name;
    std::list<Class*> _members;
public:
    Class(const std::string& name) : _name(name) {}
    void addMember(Class* member) { _members.push_back(member); }
    const std::string& name() const { return _name; }
    const std::list members() const { return _members; }
    Class* findItem(const std::string& name) const { ... }
};

我可以在Class :: findItem中执行类似的操作：


Class* Class::findItem(const std::string& n) const {
    std::list<Class>::const_iteratior i;
    for(i=_members.begin(); i!=_members.end(); ++i)
        if((*i)->name() == n) return *i;
    for(i=_members.begin(); i!=_members.end(); ++i) {
      Class* cls = (*i)->findItem(n);
      if(cls) return cls;
    }
    return 0;
}

但是，我想要发生的是findItem（）将“最近”的项返回给搜索的项。例如，如果这是我的树，每个字母代表列表层次结构中的一个级别，每个数字代表项目“值”。我希望findItem（3）返回B（3），而不是C（3）。

                        A(1)
                        |
        ----------------------------------
        B(2)                           B(3)
         |                                |
---------------------                   -----
C(3)             C(4)                    C(4)
                 |                         |
            ----------------           ----------
            D(5)  D(6)  D(7)           D(5)  D(6)

如果我没有清楚地告诉自己，请告诉我，我会更加努力。

Answer 1

使用breadth-first search。当您访问不等于查询值的节点时，将该节点推送到队列的后面。首先处理队列前面的节点。您找到的第一个匹配将是最接近根的匹配。

Class* Class::findItem(const std::string& n) const {
    std::list<Class>::const_iteratior i;
    std::queue<Class*> q;
    q.push(this);
    while (!q.empty()) {
        Class *c = q.front(); q.pop();
        if (c->name() == n) return c;
        for(i=c->_members.begin(); i!=c->_members.end(); ++i)
            q.push(i);
    }
    return NULL;
}

Answer 2

如果您执行breadth-first-search样式，即首先查看所有B，然后查看所有C等，您的匹配节点将自动成为最接近的。

Answer 3

听起来像是在要Breadth-first search。

我认为你的问题可能与家庭作业有关，所以我不会在这里透露更多细节。

Answer 4

好像您有兴趣执行BFS（广度搜索优先）。实现它的最简单方法不是通过递归，而是使用FIFO队列，在其中将邻居元素添加到最后测试的那个元素，并从队列中提取第一个元素以执行下一个检查。

插入的顺序是[A（1），B（2），B（3），C（3），...]，在测试C（3）之前你会发现B（3）。< / p>

如何递归搜索项目的列表列表，获得“最接近”的匹配

4 个答案: