向量指向另一個向量

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); 

我將調用排序函數，以從最小到最大對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;
    }
}