Insertion sort C programming - alphabet letters - c

Question

I just started to learn C and came across the Insertion Sort algorithm. I am now trying to apply it to the alphabet letters. However, the challenge I face is that I want the program to sort out the letters independently of whether or not they are caps or not.
For example, 'd' should come before 'E' in the sorted list. Here's what I have so far.
Thank you for the help.
#include <stdio.h>
#define MAX_NUMS 10
void InsertionSort(char list[]);
int main()
{
int index = 0; /* iteration variable */
char letters[MAX_NUMS]; /* list of number to be sorted */
/* Get input */
printf("Enter a word: ");
scanf("%s", letters);
printf("%s\n", letters);
InsertionSort(letters); /* Call sorting routine */
printf("pass");
/* Print sorted list */
printf("\nThe input set, in ascending order:\n");
while (letters[index] != '\0') {
printf("%c\n", letters[index]);
index += 1;
}
/* printf("%s", letters);
for (index = 0; index < MAX_NUMS; index++)
printf("%c\n", letters[index]); */
}
void InsertionSort(char list[])
{
int unsorted; /* index for unsorted list items */
int sorted; /* index for sorted items */
char unsortedItem; /* Current item to be sorted */
char lowUnsortedItem;
/* This loop iterates from 1 thru MAX_NUMS */
for (unsorted = 0; list[unsorted] != '\0'; unsorted++) {
unsortedItem = list[unsorted];
if (unsortedItem >= 'A' && unsortedItem <= 'Z') {
lowUnsortedItem = unsortedItem + 32;
}
/* This loop iterates from unsorted thru 0, unless
we hit an element smaller than current item */
for (sorted = unsorted - 1;
(sorted >= 0) && (list[sorted] > unsortedItem);
sorted--)
list[sorted + 1] = list[sorted];
list[sorted + 1] = unsortedItem; /* Insert item */
}
}

Answer 1

I think you need to use tolower() from ctype.h to obtain lowercase variant of each character and then compare those lowercase variants.
i.e. like:
lowUnsortedItem = tolower(unsortedItem)
...
for ( ...; tolower(list[sorted]) > lowUnsortedItem)
...

Answer 2

Improved answer: My previous attempt contained a bug and did not include the (later) requirement that, e.g., A should come before a. I have rewritten therefore my answer.
Since we have a more complex sorting condition than merely "less than" according to the ASCII character set, let's make the code more modular by writing a function that sorts and a function that returns whether two characters are sorted correctly (the function isLessThan below). If, at a later stage, we'd like to compare different types or use a different ordering, we can simply use a different comparison function. Alternative, we could also use this comparison function with another sorting algorithm. Also, see the C standard library's qsort which uses a similar modular approach.
To use boolean values, include the stdbool.h header. It is more convenient to use library functions to detect if a character is uppercase or lowercase, and to change between the two. Therefore, include ctype.h. Note that these functions accept int's! Be sure to only give them characters as input, otherwise their behavior is undefined.
Modified code snippet:
bool isLessThan(char lhs, char rhs)
{
if (tolower(lhs) == tolower(rhs))
return isupper(lhs) || islower(rhs);
return tolower(lhs) < tolower(rhs);
}
void InsertionSort(char list[])
{
for (size_t unsortedIdx = 1U; list[unsortedIdx] != '\0'; ++unsortedIdx)
{
char unsortedItem = list[unsortedIdx];
size_t sortedIdx = unsortedIdx;
for ( ; sortedIdx > 0U && !isLessThan(list[sortedIdx - 1U], unsortedItem); --sortedIdx)
list[sortedIdx] = list[sortedIdx - 1U];
list[sortedIdx] = unsortedItem; // Insert item
}
}
The comparison function first checks for the special property we'd like to have, e.g. A comes before a. Otherwise, we make sure both characters are lowercase and compare them.
The insertion sort algorithm now only contains the "insertion sorting logic". The indices used have been changed slightly to accommodate using the unsigned type size_t for indices, which is a good practice.
Some additional advice: scanf can be unsafe w.r.t. buffer overflows. It is best replaced by fgets and sscanf.