Question

我有一串单词，按相关性排名。相关性是一个存储在单独向量中的浮点数，但我知道两个向量的位置相互关联。

float floatTemp1, floatTemp2;
string stringTemp1, stringTemp2;
for(int m=0; m<PlayList.size()-1; m++){
    for(int i=0; i<PlayList.size(); i++){
        if(storedRelevance[i+1]>storedRelevance[i]){
            floatTemp1 = storedRelevance[i];
            floatTemp2 = storedRelevance[i+1];
            storedRelevance[i]= floatTemp2;
            storedRelevance[i+1] = floatTemp1;
            stringTemp1 = relevantPlays[i];
            stringTemp2 = relevantPlays[i+2];
            relevantPlays[i]= stringTemp2;
            relevantPlays[i+1]= stringTemp1;
        }
    }
}

所以基本上，如果位置[1]中的向量的相关性大于[0]的相关性，它将交换相关性和字符串向量中元素的位置。每次运行时都会出现分段错误。

Answer 1

我建议您使用struct存储有关单个事物的所有信息（例如，单词，相关性等），然后将std::sort与函数或{{1}一起使用比较相关性值。

Answer 2

您可以将原始数组保持在相同的顺序中，但具有已排序的间接。

std::vector<int>    sorted(PlayList.size());
for(int loop=0;loop < sorted.size();++loop) { sorted[loop] = loop;}

std::sort(sorted.begin(), sorted.end(),
           [](int lhs, int rhs){return storedRelevance[lhs]<storedRelevance[rhs]});


// Now you can access your playlist in order via the sorted vector.

// First Item
std::cout << relevantPlays[sorted[0]] << " " << storedRelevance[sorted[0]] << "\n";

Answer 3

您的[i + 1]和[i + 2]索引有时会在您的矢量存储空间中调用。

这就是你有分段错误的原因。

更好的原因是使用结构来封装数据

Struct Play {
    float score;
    string name;
}

在你的矢量中，只需要调用

std::sort(Playlist.begin(), Playlist.end());

std :: sort包含在＆lt;算法＆GT;

Answer 4

使用std::map<float, std::string>因为数据是在添加元素时排序的。

std::map<float, std::string> relevance_mapping;
std::vector<std::string> words;
std::vector<float> relevance;
//...

for(std::size_t i = 0; i < words.size(); i++) {
    relevance_mapping[relevance[i]] = words[i];
}

您现在可以迭代relevance_mapping，您将获得按相关性排序的数据。

Answer 5

您的方法存在各种级别的问题。

问题＃1，i + 1可能超过PlayList.size（）。

 for ( ... i < storedRelevance.size() ... )
        if(storedRelevance[i+1]>storedRelevance[i]){

我认为你有m和i的条件循环错误。

问题＃2，你从一个地方复制两个值，然后将它们复制回别处，当你只需要“停放”其中一个时：

            floatTemp1 = storedRelevance[i];
            floatTemp2 = storedRelevance[i+1];
            storedRelevance[i]= floatTemp2;
            storedRelevance[i+1] = floatTemp1;

更好

            floatTemp = storedRelevance[i];
            storedRelevance[i] = storedRelevance[i+1];
            storedRelevance[i+1] = floatTemp;

或更好

            std::swap(storedRelevance[i], storedRelevance[i+1]);

但同样，i + 1可能超过当前的Impleatino的PlayList.size（）。

大问题：

            stringTemp1 = relevantPlays[i];
            stringTemp2 = relevantPlays[i+2];

那个+2似乎......错误的字符串，肯定会超出数组大小。

            relevantPlays[i]= stringTemp2;
            relevantPlays[i+1]= stringTemp1;

我也不理解外部“m”循环的目的，除了确保排序总是花费O（N ^ 2）的复杂度？

如果您只是将此作为练习来理解如何实现排序，您可能需要查看其中一种替代方法：

方法1：使用struct / class赋予值locality（此是 C ++）

struct PlayListSearchResult {
    int m_relevance;
    const string& m_word; // a reference, so a short lifetime for these objects.

    PlayListSearchResult(int relevance_, const std::string& word_)
        : m_relevance(relevance_)
        , m_word(word_)
    {}
};

typedef std::vector<PlayListSearchResult> PlayListSearchResults;

// the sort:
     // given PlayListSearchResults results or &results:

     const numResults = results.size();
     bool needsRedo;
     do {
         needsRedo = false;
         for (size_t i = 0; i < numResults - 1; ++i) {
             if (!(results[i + 1].m_relevance < results[i].m_relevance))
                 continue;
             std::swap(results[i], results[i + 1]);
             needsRedo = true;
         }
     } while (needsRedo);

方法2：创建索引数组：

std::vector<size_t> indexes;
for (size_t i = 0; i < results.size(); ++i) {
    indexes.push_back(i);
}

// do the sort, but instead of swapping relevance/word, just swap the index.

但除此之外，请查看std::sort或std::map

按int排序字符串向量

5 个答案: