1

假设我有一个字符串向量列表：

[“a”，“c”，“鸭子”]

[“a”，“a”，“f”]

[“蜜蜂”，“s”，“xy”]

[“b”，“a”，“a”]

我想以这种方式对向量进行排序：

首先根据索引 0 处的元素按字典顺序排序，如果存在平局，则将根据索引 1 处的元素按字典顺序进行排序，如果存在另一个平局，则根据索引处的元素按字典顺序确定2.

所以上面的列表经过排序后会如下：

[“a”，“a”，“f”]

[“a”，“c”，“鸭子”]

[“b”，“a”，“a”]

[“蜜蜂”，“s”，“xy”]

如何实现标准库 sort() 函数来编写根据上述描述对向量列表进行排序的方法？我正在使用 C++。谢谢。

一旦知道每个向量的长度，编写比较函数就不难了。但是如果我不知道向量的长度（但我总是知道它们的长度相同）怎么办？长度为 3 的向量的比较函数：

bool CompareVector(vector<string>  first, vector<string>  second){
    if (first[0] < second[0])
       return true;
    if (first[1] < second[1])
       return true;
    if (first[2] < second[2])
       return true;
    return false;

}

因此对于长度为 n 的向量，将有 n 个 if 语句。但是我怎样才能将 if 语句的数量保持为变量呢？

这个怎么样：

 bool CompareVector(vector<string>  first, vector<string>  second){
    for (int i=0; i< first.size(); i++)
       if (first[i] < second[i])
         return true;
    return false;

}

然后我可以调用标准排序函数：

sort(vector<vector<string> >input.begin(), vector<vector<string> >input.end(), CompareVector() )

这行得通吗？谢谢。

4

3 回答 3

7

简单地调用std::sort将做正确的事情。它对向量的每个元素进行字典比较，这是递归的。

#include <vector>
#include <string>
#include <iostream>
#include <algorithm>

int main()
{
  std::vector<std::vector<std::string>> v{{"a", "c", "duck"},
                                          {"a", "a", "f"},
                                          {"bee", "s", "xy"},
                                          {"b", "a", "a"}};
  std::sort(v.begin(), v.end());

  for (const auto& v_: v)
  {
    for (const auto& s : v_)
      std::cout << s << " ";
    std::cout << std::endl;
  }
  std::cout << std::endl;
}

输出：

a a f 
a c duck 
b a a 
bee s xy
于 2014-03-03T19:31:02.523 回答
0

这将是一个示例实现：

#include <iostream>
#include <vector>

typedef std::vector<std::string> StringTuple;
typedef std::vector<StringTuple> MyList;

bool mySort(const StringTuple &a, const StringTuple &b)
{
    if (a[0]==b[0]) {
        if (a[1]==b[1]) {
            return a[2] < b[2];
        } else {
            return a[1] < b[1];
        }
    } else {
        return a[0] < b[0];
    }
}

void showList(const std::vector<StringTuple> &list)
{
    for (MyList::const_iterator it = list.begin(); it != list.end(); ++it) {
        const StringTuple &tuple = *it;
        for (StringTuple::const_iterator it2 = tuple.begin(); it2 != tuple.end(); ++it2) {
            std::cout << "\t\"" << *it2 << "\"";
        }
        std::cout << std::endl;
    }
}


int main(int argc, const char * argv[])
{
    MyList listToSort;

    listToSort.push_back({"a", "c", "duck"});
    listToSort.push_back({"a", "a", "f"});
    listToSort.push_back({"bee", "s", "xy"});
    listToSort.push_back({"b", "a", "a"});

    std::cout << "Before sort:" << std::endl;
    showList(listToSort);
    std::sort(listToSort.begin(), listToSort.end(), mySort);
    std::cout << "After sort:" << std::endl;
    showList(listToSort);
    return 0;
}
于 2014-03-03T19:39:35.407 回答
0

很简单。您需要创建虚拟数量的符号，并且需要为每个符号设置它们的索引号，从 1 到 N，并比较这些索引。像这样：

std::vector<std::string> m_vector;
std::string abc = "abcde....."; // this variable have an alphabet

void f()
{
   for(int i = 0; i < m_vector.size(); i++)
   {
       int symbol = 0;
       for(int j = 0; j < abc.length(); j++)
       {
           //second index zero because we need to get a first symbol
           if(m_vector[i][0] == abc[j]) 
           {
               symbol = j;
               break;
           }
       }

       //here your comparison, as you need
       //like this
       if(prevItem > symbol)
       {
           //to move forward
       }
   }
}

同样，您需要临时存储。

于 2014-03-03T19:41:07.613 回答