Question

我在这里有两个不同类型的数组，我正在转换为向量。

int ham_array[] = {32,71,12,45,26};

char word_array[] = {"cat", "bat", "green", "red", "taxi"};


vector < int > hamvector (ham_array, ham_array + 5);               

vector < char > wordvector(word_array, word_array + 5);

我打算调用一个sort函数来将ham_array的元素从最小到最大排序。同时，我希望word_array的排序方式与ham_vector使用引用排序的方式相同。

例如，

调用sort（hamvector）之后

ham_array[] = {12, 26, 32, 45, 71}

并排序（wordvector）

word_array[] = {"green", "taxi", "cat", "red", "bat"};

有一种简单的方法吗？

Answer 1

嗯，首先，那就是char *word_array[]，你宣称它是一个字符串的方式。

无论如何，这样做的方法是声明一个结构来保持这些东西配对：

struct t {string name; int number;};
vector<t> list;
// fill in list

// comparer to compare two such structs
bool comparer(t &a, t &b) { return a.number>=b.number; }

// and to sort the list
sort(list.begin(), list.end(), comparer);

Answer 2

如果简单，你的意思是更直接的方式，然后是。 std::sort()也支持对原始数组进行排序：

sort(word_array, word_array + 5, wordcmp);

正如Blindy所示，您需要一个比较器函数来告诉sort如何对您的单词列表进行排序。否则，您最终将按字符串所在的内存地址而不是字符串中的字母进行排序。这样的事情应该有效：

int wordcmp(const char *lhs, const char *rhs)
{
    return strncmp(lhs, rhs, 256) < 0;
}

还有一点需要注意，实际上你会希望std::vector优于原始指针数组，因为后者不是那么安全。

Answer 3

我之前尝试找到类似问题的解决方案，最终不得不手动对其进行排序。我想你可以这样做的另一种方法是编写一个分类器仿函数，它可以根据正在排序的字符串，与哪个整数相关联，并根据它进行排序。这是非常低效，因此我强烈建议您使用std::swap进行自己的手动排序。

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

template<typename KeyType, typename ValueType>
class CMappedSorter
{
    std::map<KeyType, ValueType>* const m_Mappings;
public:
    CMappedSorter(std::map<KeyType, ValueType>* Mappings) : m_Mappings(Mappings)
    {

    }

    bool operator()(KeyType& LHS, KeyType& RHS)
    {
        const ValueType LHSSortingValue = m_Mappings->find(LHS)->second;
        const ValueType RHSSortingValue = m_Mappings->find(RHS)->second;
        return (LHSSortingValue < RHSSortingValue);
    }
};

int main(int argc, char* argv[])
{
    std::vector<int> Integers;
    std::vector<std::string> Strings;

    Integers.push_back(3);
    Integers.push_back(1);
    Integers.push_back(2);

    Strings.push_back("Apple");
    Strings.push_back("Banana");
    Strings.push_back("Cherry");

    std::map<std::string, int> Mappings;

    if(Integers.size() == Strings.size())
    {
        const unsigned int ElementCount = Strings.size();

        // Generate mappings.
        auto StringsIterator = Strings.begin();
        auto IntegersIterator = Integers.begin();
        for(unsigned int i = 0; i < ElementCount; ++i)
        {
            Mappings[*(StringsIterator)] = *(IntegersIterator);
            ++StringsIterator;
            ++IntegersIterator;
        }

        // Print out before sorting.
        std::cout << "Before Sorting" << std::endl;
        std::cout << "Int\tString" << std::endl;
        StringsIterator = Strings.begin();
        IntegersIterator = Integers.begin();
        for(unsigned int i = 0; i < ElementCount; ++i)
        {
            std::cout << *(IntegersIterator) << '\t' << *(StringsIterator) << std::endl;
            ++StringsIterator;
            ++IntegersIterator;
        }

        // Sort
        std::sort(Strings.begin(), Strings.end(), CMappedSorter<std::string, int>(&(Mappings)));
        std::sort(Integers.begin(), Integers.end());

        // Print out after sorting.
        std::cout << "After Sorting" << std::endl;
        std::cout << "Int\tString" << std::endl;
        StringsIterator = Strings.begin();
        IntegersIterator = Integers.begin();
        for(unsigned int i = 0; i < ElementCount; ++i)
        {
            std::cout << *(IntegersIterator) << '\t' << *(StringsIterator) << std::endl;
            ++StringsIterator;
            ++IntegersIterator;
        }
    }
    else
    {
        std::cout << "Error: Number of elements in each container are not equivalent." << std::endl;
    }
}

矢量指向另一个向量

3 个答案: