排序算法未在for循环中递增

Question

void sortRooms()

I came up with this algorithm to sort my room struct. Inside room struct there are only 3 values (50, 120, 30) which is why I have to decrease the index by at the start and increase dec by 1 everytime. However, when i compile and it prints out

OHE 100 120
SAL 210 30
OHE 120 50

I traced out the steps on paper but I cant seem the follow why the index is not incrementing correctly so that it would go on to compare 120 with 50 and then proceed to switch those values. Any help would be appreciated.

Answer 1

Why don't you change the while loop into a for loop? For example:

for (int dec=2; (jk[0]-dec+1) > 1; dec++)
{
    if (room[i].max_students > room[jk[0] - dec].max_students)
    {            
        TEMPbuilding_code = room[i].building_code;
        room[i].building_code = room[jk[0] - dec].building_code;
        room[jk[0] - dec].building_code = TEMPbuilding_code;

        TEMProom_number = room[i].room_number;
        room[i].room_number = room[jk[0] - dec].room_number;
        room[jk[0] - dec].room_number = TEMProom_number;

        TEMPmax_students = room[i].max_students;
        room[i].max_students = room[jk[0] - dec].max_students;
        room[jk[0] - dec].max_students = TEMPmax_students;
    }
}

Also, did your order of operations in the while loop mess up? I suppose it should be jk[0] + 1 - dec or jk[0] - dec + 1 ?

Answer 2

For i=0 , you find the largest element (of all elements, except the last one, since dec starts off at 2 , not 1 ) and put it in the 0th position.

Then, for i=1 , you find the largest element (again of all elements, except the last one, which includes the first) and put it in the 1st position.

And so on.

You can't sort like that - sure, the largest element will end up at the end (which, based on your comment to the other answer, isn't what you want), but there's nothing ensuring that any of the other elements are actually sorted.

If you want to have it sorted from largest to smallest, in your inner loop, you need to stop when you get to i , so you're only picking the largest element of the remaining elements.

This is very similar to selection sort , so you could look at that for further information, or optimizations (like keeping track of the maximum and just swapping at the end, rather than swapping at each bigger element we find).