Question

根据结构向量中所有结构的每个向量中的第一个单词按字母顺序对结构向量进行排序的最佳方法是什么？

struct sentence{
    vector<string> words;
};

vector<sentence> allSentences;

换句话说，如何根据单词[0]对所有单词进行排序？

编辑：我使用了以下解决方案：

bool cmp(const sentence& lhs, const sentence & rhs)
{
  return lhs.words[0] < rhs.words[0];
}

std::sort(allSentences.begin(), allSentences.end(), cmp);

Answer 1

提供合适的比较二元函数并将其传递给std::sort。例如

bool cmp(const sentence& lhs, const sentence & rhs)
{
  return lhs.words[0] < rhs.words[0];
}

然后

std::sort(allSentences.begin(), allSentences.end(), cmp);

或者，在C ++ 11中，您可以使用lambda匿名函数

std::sort(allSentences.begin(), allSentences.end(), 
          [](const sentence& lhs, const sentence & rhs) {
                     return lhs.words[0] < rhs.words[0];}
         );

Answer 2

您需要一些可以传递给std::sort的比较函数：

bool compare(const sentence& a, const sentence& b)
{
  return a.words[0] < b.words[0];
}

如您所见，如果第一个sentences的第一个单词“小于”第二个sentence的第一个单词，则需要两个sentence并返回true。

然后您可以非常轻松地对allSentences进行排序：

std::sort(allSentences.begin(), allSentences.end(), compare);

当然，使用此比较意味着{"hello", "world"}和{"hello", "friend"}之类的句子将相等。但这就是你所要求的。

Answer 3

通常，您应该考虑三种不同类型的比较实施方案。

对象的比较，使始终有意义。它独立于您想要比较对象的场景。然后：为您的班级实施operator<。每当比较两个对象时使用此运算符（使用标准算法执行的<）。（对于单个场景，您仍然可以使用下面的其他方法“覆盖”此行为。）

为此，使用以下函数扩展您的类：
```
struct sentence{
    vector<string> words;
    bool operator<(const sentence &other) const {
        return this->words[0] < other.words[0];
    }
};
```
然后，只需在没有其他参数的句子向量上调用标准排序算法：
```
std::sort(allSentences.begin(), allSentences.end());
```
然而，你的场景听起来并不像这是最好的方法，因为通过第一个单词进行比较是你不希望总是，也许只有一种情况。
对象的比较，仅使用。在C ++ 11中，您有lambda函数（匿名，字面内联函数），它们可以直接传递给将在其中使用的算法函数，如此场景中的std::sort。这是我最喜欢的解决方案：
```
// Sort lexicographical by first word
std::sort(allSentences.begin(), allSentences.end(),
          [](const sentence& a, const sentence& b) {
    a.words[0] < b.words[0];
});
```
在C ++ 03中，你没有lambdas，请使用第3个解决方案：
一组不同的，可重复使用的比较方法，可能是参数化比较函数。示例是：通过第一个单词比较，按长度进行比较，通过其他方式进行比较...在这种情况下，将比较函数实现为独立函数并使用函数指针，或将它们实现为函子（可以参数化）。此外，存储在变量中的lambda在这种情况下可以完成工作。

此方法的优点是命名比较方法，为它们提供含义。如果对同一个对象使用不同的比较，但重复使用它们，这是一个巨大的优势：
```
// Lexicographical comparison by the first word only
bool compareLexByFirstWord(const sentence& a, const sentence& b) {
    return a.words[0] < b.words[0];
}

// Lexicographical comparison by all words
bool compareLex(const sentence& a, const sentence& b) {
    return a.words < b.words;
}

// Decide which behavior to use when actually using the comparison:
std::sort(sentence.begin(), sentence.end(), compareLexByFirstWord);
std::sort(sentence.begin(), sentence.end(), compareLex);
```

如何根据要排序的向量中的向量<string>对结构的向量进行排序？</string>

3 个答案: