Question

我编写了一个简单的冒泡排序算法，但是在运行时它会返回奇怪的结果......

我正在尝试对并行向量进行排序（不确定这是否是正确的术语，我将并行数组的概念应用于向量，以便我可以在运行时修改大小）构成联系人列表

与向量和冒泡排序有关的代码：

#include <cstdlib>
#include <iostream>
#include <iomanip>
#include <string>
#include <vector>

using namespace std;

int main(int argc, char** argv) {

    vector <long long int> numbers;
    vector <string> names;

    names.push_back("jack");
    numbers.push_back(6515551234);
    names.push_back("jill");
    numbers.push_back(6515554321);
    names.push_back("bob");
    numbers.push_back(6515557777);
    names.push_back("aaron");
    numbers.push_back(6665559999);
    names.push_back("fred");
    numbers.push_back(1115552222);

    int index = -1;
    long int temp = -1;
    int pass = -1;
    string tempName;
    int sortChoice;

    for (pass = 0; pass < names.size(); pass++) {
        for (index = 0; index < names.size() - pass; index++) {
            if ( names[index] > names[index + 1] ) {


            temp = numbers[index]; 
            numbers[index] = numbers[index + 1]; 
            numbers[index + 1] = temp; 

            tempName = names[index];
            names[index] = names[index + 1];
            names[index + 1] = tempName;

            }
        }
   }

   for(int i = 0; i < numbers.size(); i++) {
       cout << names[i] << ": " << numbers[i] << endl;
   }

    return 0;

}

输出：

: 465675315720                                                                                                                                  
aaron: 6665559999                                                                                                                               
bob: 6515557777                                                                                                                                 
fred: 1115552222                                                                                                                                
jack: 6515551234

似乎无论我如何改变矢量本身，最后一个总是被切断，并且在开头没有名称和（看似）随机数。有没有人见过这个？

我唯一能想到的是，虽然排序是处理，但是内存中出现问题，导致指向不正确的内存位置？...而且它始终是最后一个元素的事实让我认为问题属于到循环的最后一次迭代。

另外，我做了一个版本，用数字而不是名字排序，每次都很完美。它是相同的代码，但在算法循环中使用数字[index]代替名称[index]。

P.S。 - 我对StackOverflow和编码一般都是新手，所以如果我在格式化这篇文章时犯了任何错误，请告诉我，我会更改它们。我希望我提供了足够的信息。

提前谢谢！

Answer 1

对于每个循环，您应该比较从第一个到最后的每个邻域。

你的错误：

for（index = 0; index＆lt; names.size（） - pass; index ++）{

应该是

for（index = 0; index＆lt; names.size（） - 1; index ++）{

这是一个示例

开始：5 4 3 2 1

循环：0

指数：0：[5 4] 3 2 1 =＆gt; [4 5] 3 2 1

指数：1：4 [5 3] 2 1 =＆gt; 4 [3 5] 2 1

指数：2：4 3 [5 2] 1 =＆gt; 4 3 [2 5] 1

index：3：4 3 2 [5 1] =＆gt; 4 3 2 [1 5]

循环：1

指数：0：[4 3] 2 1 5 =＆gt; [3 4] 2 1 5

指数：1：3 [4 2] 1 5 =＆gt; 3 [2 4] 1 5

指数：2：3 2 [4 1] 5 =＆gt; 3 2 [1 4] 5

指数：3：3 2 1 [4 5] =＆gt; 3 2 1 [4 5]

循环：2

指数：0：[3 2] 1 4 5 =＆gt; [2 3] 1 4 5

指数：1：2 [3 1] 4 5 =＆gt; 2 [1 3] 4 5

指数：2：2 1 [3 4] 5 =＆gt; 2 1 [3 4] 5

指数：3：2 1 3 [4 5] =＆gt; 2 1 3 [4 5]

循环：3

指数：0：[2 1] 3 4 5 =＆gt; [1 2] 3 4 5

指数：1：1 [2 3] 4 5 =＆gt; 1 [2 3] 4 5

指数：2：1 2 [3 4] 5 =＆gt; 1 2 [3 4] 5

指数：3：1 2 3 [4 5] =＆gt; 1 2 3 [4 5]

循环：4

指数：0：[1 2] 3 4 5 =＆gt; [1 2] 3 4 5

指数：1：1 [2 3] 4 5 =＆gt; 1 [2 3] 4 5

指数：2：1 2 [3 4] 5 =＆gt; 1 2 [3 4] 5

指数：3：1 2 3 [4 5] =＆gt; 1 2 3 [4 5]

最终结果：1 2 3 4 5

Answer 2

您上面编写的代码不冒泡排序！

然而，试试这个，这是冒泡排序：

flexbox

我建议您使用pair而不是两个向量

冒泡排序不能按预期工作C ++

2 个答案: