在冒泡排序中显示 2 个相同的值

Question

I am sorting values to find the top 3 values. However my bubble sort only can display one value if there is 2 same highest value. for example: output:

Please select broadband type (1 - DSL): 1
 3800 , month 1
 1700 , month 3
 1400 , month 4

expected output:

Please select broadband type (1 - DSL): 1
 3800 , month 1
 3800 , month 2
 1400 , month 4

Array File:

int file[3][6] =
{
    { 3800, 3800, 1700, 1400, 1300, 1285 },
    { 106900, 100400, 89600, 76900, 61500, 59200 },
    { 1260300, 1269900, 1285400, 1298800, 1316900, 1401280 }
};

Function:

{

    int type3, c, d, highest = 0, prehighest = 99999999999, month = 0;

    printf("1. DSL \n");
    printf("2. Cable Modem \n");
    printf("3. Fibre Based \n");

    printf("Please select broadband type (1 - DSL): ");
    scanf(" %d", &type3);

    if (type3 <= 3)
    {
        for (d = 0; d < 3; d++)
        {
            for (c = 0; c < 6; c++)
            {
                if (file[type3 - 1][c] > highest && file[type3 - 1][c] < prehighest)
                {
                    highest = file[type3 - 1][c];
                    month = c + 1;
                }
            }

            if (file[type3 -1][3])
                printf(" %d , month %d \n", highest, month);

            prehighest = highest;
            highest = 0;
        }
    }
    else
    {
        printf("Error! Please enter a valid option. \n");
    }
    type3 =getchar();
}

Answer 1

OK, you want to find the 3 highest values...

At first, as you allow negative values, you should check lower bound, too (actually, you'd even need to check for 0 for unsigned as well), so first:

if (1 <= type3 && type3 <= 3)

Then for not having to subtract each time in the loop, I'd do that once before:

{
    --type3;

Actually you don't do any bubble sort, as you don't modify the input array. You would have to bubble up:

if(file[type3 - 1][c] > file[type3 - 1][c - 1]
{
    // swap positions c and c - 1!!!
}

For above, you'd have to start counting from 1, of course...

Then after sorting, you'd find the elements you look for at the very end.

Your code instead looks for the highest element not yet found, though (as is, complexity is just the same as with bubble sort: O(k*n) , if you want to find the k largest elements out of n ones – there are ways to do better, but these would be overkill for such little set of inputs...).

However, your algorithm cannot cope with duplicates; as you modify prehighest to higest after having found first of the duplicates, the condition

file[type3 - 1][c] < prehighest

can't be true any more for any one of the further duplicates.

You could adjust your algorithm by counting the number of duplicates:

if (file[type3 - 1][c] > highest && file[type3 - 1][c] < prehighest)
{
    /* ... */
    count = 1;
}
else
{
    count += file[type3 - 1][c] == highest;
}

Now you can output count times the value you found.

So you'll modify the loop, eg:

for(d = 0; d < 3; d += count)

You might find more values than required, though, so you might do something like:

int min = MIN(count, required);
required -= min;
for(int i = 0; i < min; ++i) { /* print */ };

In outer most loop, you then could then alternatively check for required being != 0:

for(int required = 3; required; )
{
    for (c = 0; c < 6; c++)
    {
    }
    // print and adjust required
}

With above loop there's a corner case left open, though: If you look for more elements that are contained in the array, you'll end up in an endless loop (would apply for the loop with d += count as well!). If that corner case might be realistic in any further scenario, you'd have to handle it explicitly.