如何从STL容器中通过子字符串删除元素

Question

我有一个对象向量（对象是术语节点，在其他字段中包含带有术语字符串的字符串字段）

class TermNode {
private:
    std::wstring term;
    double weight;
    ...
public:
    ...
};

经过一些处理和计算分数后，这些对象最终存储在TermNode指针的向量中，例如

std::vector<TermNode *> termlist;

此向量的结果列表最多包含400个条目，如下所示：

DEBUG: 'knowledge' term weight=13.5921
DEBUG: 'discovery' term weight=12.3437
DEBUG: 'applications' term weight=11.9476
DEBUG: 'process' term weight=11.4553
DEBUG: 'knowledge discovery' term weight=11.4509
DEBUG: 'information' term weight=10.952
DEBUG: 'techniques' term weight=10.4139
DEBUG: 'web' term weight=10.3733
...

我想要做的是清理最终列表中的子字符串 ，这些子字符串也包含在术语列表中的短语中。 例如，在上面的列表片段中，有一个短语“知识发现” ，因此我想删除单个术语“知识”和“发现” ，因为它们也在列表中并且在此上下文中是多余的。 我想保留包含单个术语的短语。 我也在考虑删除所有等于或少于3个字符的字符串。 但这只是目前的想法。

对于此清理过程，我想使用remove_if / find_if（使用新的C ++ lambdas）编码一个类，并且将该代码放在一个紧凑的类中会很好。

我不确定如何解决这个问题。 问题是，我首先必须通过将标记设置为删除标记来识别要删除的字符串。 那意味着我将不得不对该列表进行预处理。 我将不得不找到单个术语以及包含这些单个术语之一的短语。 我认为这并非易事，需要一些高级算法。 使用后缀树来标识子字符串？

向量上的另一个循环以及同一向量的副本可能需要清理。 我正在寻找一种及时有效的方法。

我一直在使用remove_if / find_if和std :: list删除不兼容的迭代器中所示的想法或方向，以及从std :: vector擦除多个对象中使用的想法？ 。

因此，问题在于，基本上有一种聪明的方法可以做到这一点，并且可以避免出现多个循环，并且我如何确定要删除的单个术语？ 也许我真的很想念什么，但可能有人在外面给我一个很好的提示。

感谢您的想法！

更新

我采用Scrubbins建议的方式实现了删除冗余单项的操作，如下所示：

/**
 * Functor gets the term of each TermNode object, looks if term string
 * contains spaces (ie. term is a phrase), splits phrase by spaces and finally
 * stores thes term tokens into a set. Only term higher than a score of 
 * 'skipAtWeight" are taken tinto account.
 */
struct findPhrasesAndSplitIntoTokens {
private:
    set<wstring> tokens;
    double skipAtWeight;

public:
    findPhrasesAndSplitIntoTokens(const double skipAtWeight)
    : skipAtWeight(skipAtWeight) {
    }

    /**
     * Implements operator()
     */
    void operator()(const TermNode * tn) {
        // --- skip all terms lower skipAtWeight
        if (tn->getWeight() < skipAtWeight)
            return;

        // --- get term
        wstring term = tn->getTerm();
        // --- iterate over term, check for spaces (if this term is a phrase)
        for (unsigned int i = 0; i < term.length(); i++) {
            if (isspace(term.at(i))) {
if (0) {
                wcout << "input term=" << term << endl;
}
                // --- simply tokenze term by space and store tokens into 
                // --- the tokens set
                // --- TODO: check if this really is UTF-8 aware, esp. for
                // --- strings containing umlauts, etc  !!
                wistringstream iss(term);
                copy(istream_iterator<wstring,
                        wchar_t, std::char_traits<wchar_t> >(iss),
                    istream_iterator<wstring,
                        wchar_t, std::char_traits<wchar_t> >(),
                    inserter(tokens, tokens.begin()));
if (0) {
                wcout << "size of token set=" << tokens.size() << endl;
                for_each(tokens.begin(), tokens.end(), printSingleToken());
}
            }
        }
    }

    /**
     * return set of extracted tokens
     */
    set<wstring> getTokens() const {
        return tokens;
    }
};

/**
 * Functor to find terms in tokens set
 */
class removeTermIfInPhraseTokensSet {
private:
    set<wstring> tokens;

public:
    removeTermIfInPhraseTokensSet(const set<wstring>& termTokens)
    : tokens(termTokens) {
    }

    /**
     * Implements operator()
     */
    bool operator()(const TermNode * tn) const {
        if (tokens.find(tn->getTerm()) != tokens.end()) {
            return true;
        }
        return false;
    }
};

...

findPhrasesAndSplitIntoTokens objPhraseTokens(6.5);
objPhraseTokens = std::for_each(
    termList.begin(), termList.end(), objPhraseTokens);
set<wstring> tokens = objPhraseTokens.getTokens();
wcout << "size of tokens set=" << tokens.size() << endl;
for_each(tokens.begin(), tokens.end(), printSingleToken());

// --- remove all extracted single tokens from the final terms list
// --- of similar search terms 
removeTermIfInPhraseTokensSet removeTermIfFound(tokens);
termList.erase(
    remove_if(
        termList.begin(), termList.end(), removeTermIfFound),
    termList.end()
);

for (vector<TermNode *>::const_iterator tl_iter = termList.begin();
      tl_iter != termList.end(); tl_iter++) {
    wcout << "DEBUG: '" << (*tl_iter)->getTerm() << "' term weight=" << (*tl_iter)->getNormalizedWeight() << endl;
    if ((*tl_iter)->getNormalizedWeight() <= 6.5) break;
}

...

我无法使用C ++ 11 lambda语法，因为在我的ubuntu服务器上当前安装了g ++ 4.4.1。 无论如何。 它现在可以完成工作。 可行的方法是与其他搜索结果集一起检查所得加权术语的质量，并查看如何提高质量，并找到一种方法来结合原始查询术语来提高相关性。 这可能不是一件容易的事，我希望会有一些“简单的启发式”。 但这可能是另一个新问题，当进一步执行更多操作时：-)

因此，感谢大家对思想的丰富贡献！

Answer 1

您需要做的是，首先遍历列表，然后将所有多单词值拆分为单个单词。 如果您允许使用Unicode，则意味着您将需要类似于ICU的BreakIterators的内容，否则您可以进行简单的标点/空格分隔。 将每个字符串拆分为组成词后，请使用哈希图保留所有当前词的列表。 当您达到多字值时，可以检查是否已找到该字。 这应该是识别重复项的最简单方法。

Answer 2

我可以建议您以这种方式使用“删除”惯用语：

struct YourConditionFunctor {
    bool operator()(TermNode* term) {
        if (/* you have to remove term */) {
           delete term;
           return true;
        }
        return false;
    }
};

然后写：

termlist.erase(
    remove_if(
        termlist.begin(),
        termlist.end(), 
        YourConditionFunctor()
    ), 
    termlist.end()
);