Bubble рода не работает, как ожидалось C++

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


      temp = numbers[index]; 
      numbers[index] = numbers[pass]; 
      numbers[pass] = temp; 

      tempName = names[index]; 
      names[index] = names[pass]; 
      names[pass] = tempName; 

      } 
     } 
    } 

я предлагаю вы используете pair вместо двух векторов

Answer 2

для каждого цикла, вы должны сравнивать каждую окрестность, от первого до конец.

ваша ошибка:

for (index = 0; index < names.size() - pass; index++) {

должно быть

for (index = 0; index < names.size() - 1; index++) {

Здесь образец

старт: 5 4 3 2 1

петля: 0

индекс : 0: [5 4] 3 2 1 => [4 5] 3 2 1

индекс: 1: 4 [5 3] 2 1 => 4 [3 5] 2 1

Индекс: 2: 4 3 [5 2] 1 => 4 3 [2 5] 1

индекс: 3: 4 3 2 [5 1] => 4 3 2 [1 5]

цикл: 1

индекс: 0: [ 4 3] 2 1 5 => [3 4] 2 1 5

индекс: 1: 3 [4 2] 1 5 => 3 [2 4] 1 5

Индекс: 2: 3 2 [4 1] 5 => 3 2 [1 4] 5

Индекс: 3: 3 2 1 [4 5] => 3 2 1 [4 5]

цикл: 2

индекс: 0: [3 2] 1 4 5 => [2 3] 1 4 5

индекс: 1: 2 [3 1] 4 5 => 2 [1 3] 4 5

индекс: 2: 2: 1 [3 4] 5 => 2 1 [3] 4 5

Inde х: 3: 2 1 3 [4 5] => 2 1 3 [4 5]

цикл: 3

Индекс: 0: [2 1] 3 4 5 => [1 2] 3 4 5

индекс: 1: 1 [2] 3 4 5 => 1 [2] 3 4 5

индекс: 2: 1 2 [3] 4 5 => 1 2 [3] 4 5

индекс: 3: 1 2 3 [4 5] => 1 2 3 [4 5]

цикл: 4

Индекс: 0: [1] 2 3 4 5 => [1 2] 3 4 5

индекс: 1: 1 [2] 3 4 5 => 1 [2] 3 4 5

индекс: 2: 1 2 [3] 4 5 => 1 2 [3] 4 5

индекс: 3: 1 2 3 [4 5] => 1 2 3 [4 5]

окончательный результат : 1 2 3 4 5