Выпускает алфавитный массив массивов. Работает от Z до A, но не от A до Z

В настоящее время я работаю над небольшим проектом во время зимних каникул и столкнулся с некоторыми проблемами.

Вот структура, с которой я работаю:

struct student{
string last_name;
string first_name;
double exams[NUM_EXAMS];
double average;
char letter_grade;
bool passed;};

Я пытаюсь алфавитировать по фамилии от А до Я. Вот функция алфавита, а также функция подкачки, которую она вызывает:

void alphabetize(student class_list[], int count)
{
for (int pass = 0; pass < count; pass++)
for (int x = 0; x < count - pass; x++)
if (class_list[x].last_name < class_list[x + 1].last_name)
swap(class_list, x);
}

void swap(student class_list[], int x)
{
student temp[MAX_STUDENTS];

temp[x] = class_list[x];
class_list[x] = class_list[x + 1];
class_list[x + 1] = temp[x];
}

Это работает отлично и алфавитный массив массивов в обратном порядке от Z до A.

Вот исходный вывод без сортировки:

   Jones        John  87  66  92  88 83.25  B  Pass
Smith       Peter  55  66  63  58  60.5  D  Pass
Quest      Nicole  79  89  99  98 91.25  A  Pass
Wu          Li  98  99 100  91    97  A  Pass
West     Vincent  80  80  88  89 84.25  B  Pass
McCartin       Susan  80  90 100  85 88.75  B  Pass
Ibrahima     Shuhuru  45  65  54  60    56  F  Fail
Burns  Antoinette  90  90  90  90    90  A  Pass
Ng    Lawrence 100 100  90  76  91.5  A  Pass
Ziggler      Bertha  65  55  58  58    59  F  Fail
Ionella        Jean 100 100 100 100   100  A  Pass
Vogler      Samuel  40  50  60  70    55  F  Fail
Perry         Jim  67  87  76  54    71  C  Pass

и вот вывод с помощью

if (class_list[x].last_name < class_list[x + 1].last_name)

в алфавитной функции.

 Ziggler      Bertha  65  55  58  58    59  F  Fail
Wu          Li  98  99 100  91    97  A  Pass
West     Vincent  80  80  88  89 84.25  B  Pass
Vogler      Samuel  40  50  60  70    55  F  Fail
Smith       Peter  55  66  63  58  60.5  D  Pass
Quest      Nicole  79  89  99  98 91.25  A  Pass
Perry         Jim  67  87  76  54    71  C  Pass
Ng    Lawrence 100 100  90  76  91.5  A  Pass
McCartin       Susan  80  90 100  85 88.75  B  Pass
Jones        John  87  66  92  88 83.25  B  Pass
Ionella        Jean 100 100 100 100   100  A  Pass
Ibrahima     Shuhuru  45  65  54  60    56  F  Fail
Burns  Antoinette  90  90  90  90    90  A  Pass

Если я переключусь

if (class_list[x].last_name < class_list[x + 1].last_name)

в алфавитной функции для

if (class_list[x].last_name > class_list[x + 1].last_name)

Я думал, что это решит проблему и отсортирует массив от А до Я, а не от Я до А. Вот что я получаю в качестве вывода:

                    -6.27744e+066-6.27744e+066-6.27744e+066-6.27744e+066-6.2
7744e+066  ═  Pass
Burns  Antoinette  90  90  90  90    90  A  Pass
Ibrahima     Shuhuru  45  65  54  60    56  F  Fail
Ionella        Jean 100 100 100 100   100  A  Pass
Jones        John  87  66  92  88 83.25  B  Pass
McCartin       Susan  80  90 100  85 88.75  B  Pass
Ng    Lawrence 100 100  90  76  91.5  A  Pass
Perry         Jim  67  87  76  54    71  C  Pass
Quest      Nicole  79  89  99  98 91.25  A  Pass
Smith       Peter  55  66  63  58  60.5  D  Pass
Vogler      Samuel  40  50  60  70    55  F  Fail
West     Vincent  80  80  88  89 84.25  B  Pass
Wu          Li  98  99 100  91    97  A  Pass

Как вы можете видеть, я сейчас скучаю по тому, кто будет последним учеником в этом списке, и вместо этого результаты выплевывают эти числа. Я не понимаю, почему это работает наоборот, и я не уверен, как это исправить. Любой совет будет принята с благодарностью!

РЕДАКТИРОВАТЬ: Благодаря Jarod42 я разработал решение моей проблемы. Это была проблема «вне границ» с x + 1. Вот код, который я использовал для решения проблемы. Он работает с входным файлом, который у меня есть, но я не уверен, будет ли он работать с другим. Если кто-то видит проблему с этим, пожалуйста, дайте мне знать.

void alphabetize(student class_list[], int count)
{
for (int pass = 0; pass < count; pass++)
for (int x = 0; x < count - pass; x++)
if (class_list[x].last_name > class_list[x + 1].last_name)
if (count > x + 1)
swap(class_list, x);
}

0

Решение

С:

for (int x = 0; x < count - pass; x++)
if (class_list[x].last_name < class_list[x + 1].last_name)

Вы можете иметь вне доступа с x + 1 когда pass == 0,

С STL вы можете просто сделать:

std::sort(std::begin(students), std::end(students),
[](const student& lhs, const student& rhs) {
return lhs.last_name < rhs.last_name; // and > for the other order
});
2

Другие решения

Если вы действительно не хотите использовать стиль C ++ (векторы а также СТЛ, например std :: sort), попробуйте изменить эту строку:

for (int x = 0; x < count - pass; x++)

в:

for (int x = 0; x < count - pass - 1; x++)

Вы должны понимать инварианты. Ваш алгоритм сортировки гарантирует, что на каждом этапе проходить, у тебя последний проходить позиции в вашем массиве отсортированы. Это где -проходить происходит от. Тот -1 Это связано с тем, что на каждом шаге цикла for вы сравниваете текущую позицию со следующей.

Тем не менее, я настоятельно рекомендую вам использовать станд :: вектор а также станд :: сортировать, если вы не пытаетесь научить себя алгоритму сортировки.

0