How Do I Sort Structs by Different Keys?

The duplication between sort_by_name and sort_by_gpa is the setup for function pointers in Lesson 4.6. Recognizing duplicate code and understanding what varies (just the comparison) is how you design flexible, reusable functions. This same insight drives Java’s Comparator interface.

< compares pointer addresses (where the strings are stored in memory), which is meaningless. strcmp compares the actual character content. strcmp(a, b) < 0 means string a comes before string b alphabetically.

With char name[50] (fixed array inside struct), the swap copies all 50 bytes as part of the struct copy. With char *name (pointer), only the pointer is copied — both structs would point to the same string after a swap, which is actually fine for sorting purposes.

The comparison line. sort_by_name uses strcmp(roster[j].name, roster[min].name) < 0. sort_by_gpa uses roster[j].gpa < roster[min].gpa. Everything else — the loops, the swap, the structure — is identical. Function pointers (Lesson 4.6) will let you write one sort function that accepts any comparison.

When structs are large (hundreds of bytes), swapping them is expensive — each swap copies the entire struct three times. An alternative: sort an array of pointers to structs instead:

void sort_ptrs_by_name(Student *ptrs[], int size)
{
    for (int i = 0; i < size - 1; i++)
    {
        int min = i;
        for (int j = i + 1; j < size; j++)
        {
            if (strcmp(ptrs[j]->name, ptrs[min]->name) < 0)
            {
                min = j;
            }
        }
        if (min != i)
        {
            Student *temp = ptrs[i];     // Swap pointers (8 bytes each)
            ptrs[i] = ptrs[min];
            ptrs[min] = temp;
        }
    }
}

The pointer approach swaps 24 bytes per swap regardless of struct size. The tradeoff: you need to set up the pointer array first and use -> instead of . for access. For Lab 7’s struct sizes, sorting directly is fine. In production code with thousands of large records, pointer sorting is standard.

This is also how qsort works internally — it uses void * and memcpy to swap arbitrary-sized elements, but the callback pattern lets you avoid knowing the swap details.

Descending order: Flip the comparison. For ascending GPA: roster[j].gpa < roster[min].gpa. For descending: roster[j].gpa > roster[min].gpa. With strcmp, ascending name: strcmp(a, b) < 0. Descending: strcmp(a, b) > 0.

Multi-key sorting (e.g., sort by GPA, break ties by name):

void sort_by_gpa_then_name(Student roster[], int size)
{
    for (int i = 0; i < size - 1; i++)
    {
        int min = i;
        for (int j = i + 1; j < size; j++)
        {
            if (roster[j].gpa < roster[min].gpa ||
                (roster[j].gpa == roster[min].gpa &&
                 strcmp(roster[j].name, roster[min].name) < 0))
            {
                min = j;
            }
        }
        if (min != i)
        {
            Student temp = roster[i];
            roster[i] = roster[min];
            roster[min] = temp;
        }
    }
}

The comparison checks GPA first. If GPAs are equal, it falls through to comparing names. This is equivalent to Java’s Comparator.comparing(Student::getGpa).thenComparing(Student::getName).