C++ needsRedo=正确； } }而（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:：向量索引；
对于（size_t i=0；i

---

但是，如果

i

最大，并且您正在访问

somearray[i+1]

，则只需查看或越界访问。调试器是帮助探索程序崩溃原因的绝佳工具使用

std:：map

此外，您可能需要查看std:：swap（），例如

std:：swap（storedRelevance[i]，storedRelevance[i+1]）

以降低交换的成本。此外，您是否正在构建自己的排序算法作为练习？当

i

最大且您正在访问

somearray[i+1]

时进行越界访问。调试器是帮助探索程序崩溃原因的绝佳工具使用

std:：map

此外，您可能需要了解std:：swap（），例如，

std:：swap（存储相关性[i]，存储相关性[i+1]）以降低掉期成本。此外，您是否正在构建自己的排序算法作为练习？
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];
}

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

Struct Play {
    float score;
    string name;
}

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

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

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

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

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

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

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.