有没有一种方法可以使用排序将向量与字符串序列进行比较？

Question

我有一个vector<string>，其中包含几个基于用户输入的单词。它们都使用名为container 的变量存储在向量中。我需要将字符串中的单词排列成非常规的 QWERTY 顺序，或者换句话说，我需要根据字符串对它们进行排序 string sequence = "QWERTYUIOPASDFGHJKLZXCVBNM"; 所以示例运行看起来像这样

Enter a word: apple Enter a word: pear Enter a word: peach

Words sorted in QWERTY order: pear peach apple

我目前只能存储这些字符串，而且由于它们不是按字母顺序排列的，我不能在 if 语句中使用字符值，

有人提示我使用排序选择或插入来将我的向量字符串与 QWERTY 序列进行比较，但我无法在我的教科书或网上找到任何关于如何将其应用于我的代码的示例。任何帮助将不胜感激，感谢您的宝贵时间。

Answer 1

只需使用std::string::find 查找符号的索引并比较它们：

bool sequenceLess( const std::string &s1, const std::string &s2 )
{
    static const std::string sequence = "QWERTYUIOPASDFGHJKLZXCVBNM";
    for( size_t i = 0; i < s1.length(); ++i ) {
        if( i >= s2.length() ) return false;
        auto idx1 = sequence.find( ::toupper( s1[i] ) );
        auto idx2 = sequence.find( ::toupper( s2[i] ) );
        if( idx1 == idx2 ) continue;
        return idx1 < idx2;
    }
    return true;
}

另一个版本是将字符串转换为索引向量并进行比较：

std::vector<size_t> convert( const std::string &s )
{
    static const std::string sequence = "QWERTYUIOPASDFGHJKLZXCVBNM";
    std::vector<size_t> r( s.size() );
    std::transform( s.begin(), s.end(), r.begin(), [sequence]( char c ) {
         return sequence.find( ::toupper( c ) );
     } );
    return r;
}

// now comparison is obvious
bool sequenceLess( const std::string &s1, const std::string &s2 )
{
    return convert( s1 ) < convert( s2 );
}

这个解决方案效率低，但出于学习目的应该没问题。

Answer 2

一种选择是用您的特殊字母表中的相应字符替换每个字符。然后进行排序并改回来。

例如：

we -> bc, er -> cd

Answer 3

您可以尝试自定义排序。 请参考此链接 Sorting a vector of custom objects

下面是我的代码示例，但我处理的是小写字母。

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

using namespace std;

struct mySort{
     inline bool operator() (const string& s1, const string& s2)
    {
        bool isSort = false;

        if(s1.length() < s2.length()){
            return true;
        }else if(s1.length() > s2.length()){
            return false;
        }

        //s1.length() == s1.length()
        string sequence = "QWERTYUIOPASDFGHJKLZXCVBNM";
        int index1 = 0 , index2 = 0;
        for(int i = 0 ; i < s1.length() ; i++){

            for(int j = 0 ; j < sequence.length() ; j++){
                if(s1[i] == sequence[j]){
                    index1 = j;

                }
                if(s2[i] == sequence[j]){
                    index2 = j;
                }
            }

            if(index1 < index2){return true;}
        }

        return false;
    }
};

int main(){


    vector<string> myVector;
    myVector.push_back("APPLE");
    myVector.push_back("PEAR");
    myVector.push_back("PEACH");
    sort(myVector.begin(), myVector.end(), mySort());
    for(int i = 0 ; i < myVector.size() ; i++){
        cout<<myVector[i]<<endl;
    }

    return 1;
}

这是结果，

PS : 可能我漏掉了一些条件，只是分享给大家，如何应用自定义排序。

Answer 4

您可以为字符串重载< 运算符，然后使用位于<algorithm> 的c++ 函数sort() 我不太明白您究竟想如何使用该规则对字符串进行排序，因此由您对两个字符串的比较进行编码，就是这样。

Answer 5

编辑：添加了查找表并更正了 getless 中的测试。

这是另一种使用 std::sort 和一个函数的解决方案，该函数测试每个字符串并在一个字符串按 QWERTY 顺序小于另一个字符串时返回 true：

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

typedef std::vector<std::string> StringVect;
std::string sequence = "QWERTYUIOPASDFGHJKLZXCVBNM";
std::vector<int> lookup(26);

bool getless(const std::string& s1, const std::string& s2)
{
    for (size_t i = 0; i < std::min(s1.size(), s2.size()); ++i)
        if (s1[i] != s2[i])
            return (lookup[toupper(s1[i])-'A'] < lookup[toupper(s2[i])-'A']);
    return s1.size() < s2.size();
};

int main()
{
    StringVect sv = {{ "apple" },{ "pear" },{ "peach" }};

    // build the lookup table
    int i = 0;
    std::for_each(sequence.begin(), sequence.end(), [&](char ch) {lookup[ch-'A'] = i; ++i; });

    // sort the data
    std::sort(sv.begin(), sv.end(), getless);

    // output results
    for (auto& s : sv)
      std::cout << s << "\n";
}

Live Example

构建了一个查找表，将字符的相对 ASCII 位置映射到在sequence 字符串中找到该字符的位置。比如lookup[0]是A的位置（即10），lookup[1]是B的位置（即23），等等

getless 函数扫描字符串并测试与每个字符串的i'th 字符相关联的字符以及相应的查找位置。

for 循环基本上“等待”被比较的两个字符串中的字符差异。如果s1 字符串中的字符的查找值小于s2 中字符的查找值，那么我们立即返回“true”，即s1 s2，我们返回 false。

如果字符相等，我们会继续循环，直到用完要比较的字符。如果两个字符串在我们退出 for 循环之前都相等，我们返回真或假，具体取决于字符串的长度（较短的字符串意味着 s1