Question

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

[“a”，“c”，“duck”]

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

[“bee”，“s”，“xy”]

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

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

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

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

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

[“a”，“c”，“duck”]

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

[“bee”，“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() )

这会有用吗？感谢。

Answer 1

只需致电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

Answer 2

这将是一个示例实现：

#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;
}

Answer 3

很简单。您需要创建虚拟的符号质量，并且需要为每个符号设置其索引号，从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
       }
   }
}

同样，你需要临时商店。

根据优先级按字典顺序对向量列表进行排序

3 个答案: