Sorting in alphabetical with å ä ö - c++

Question

I have an algoritm sorting words in alphabetical by the letters value, this all works fine until I include å ä ö as they return a int value ranging from -103 to -124. Becuse of this the order of the words are like this ä å ö a for example, when it should be a å ä ö. So how do I make it sort it correctly with å ä ö last?
Edit: Im not allowed to use fancy functions, that is why this code is so bare boned, also using using namespace std
My code:
pali is a vector of type string that I use to store the words
void SortPal() {
int antal = pali.size();
string tempO;
bool byte = false;
for (int i = 0; i < antal - 1; i++) { //går igenom alla ord i vectorn
if (int(pali[i][0]) > int(pali[i + 1][0])) {
tempO = pali[i];
pali[i] = pali[i + 1];
pali[i + 1] = tempO;
i = -1;
}
else if (int(pali[i][0]) == int(pali[i + 1][0])) { //Om första bokstaven är samma kollar den följande
int minsta = pali[i].size();
if (minsta > pali[i + 1].size()) {
minsta = pali[i + 1].size();
}
for (int a = 1; a < minsta-1; a++){
if (int(pali[i][a]) > int(pali[i + 1][a])) { //byter om någon av bokstäverna efter den första är mindre än bokstäverna i andra ordet
tempO = pali[i];
pali[i] = pali[i + 1];
pali[i + 1] = tempO;
i = -1;
byte = true;
break;
}
}
if (byte == false && pali[i].size() > pali[i + 1].size()) { // byter om pali i+1 är mindre än pali i
tempO = pali[i];
pali[i] = pali[i + 1];
pali[i + 1] = tempO;
i = -1;
}
}
}
}

Answer 1

Generally speaking, there's no relationship between the alphabetical order of letters in any given language and numerical codes assigned to said letters in any given character set. In order to compare strings according to the alphabetical order of a given language (or more generally the collation order of the current locale), C has a special function called strcoll.
In order to use it, you need to set up your locale accordingly. Unfortunately, locale names are not standard in C. If you are on Windows, the linked example is unlikely to work.
This is what you should be using in real software. It matters little for you assignment since you are not supposed to use fancy library functions. You need to implement a function similar to strcoll yourself, and it should only work for your language.
In a language where each character has its own place in the alphabet, this function is simple: write a function that takes a character and returns its place in the alphabet (e.g. for 'a' return 1, for 'b' return 2, ..., for 'å' return 27, for 'ä' return 28...) Compare the strings according to numbers returned by this function. This may or may not take into account letter case depending on what exact sort order you want.
If you don't want to write a big switch, you can use the fact that letters that are in ASCII are already ordered as you want, you only need to fix the order of three additional letters. So you can write something like this:
int collation_order(int ch) {
switch (ch) {
case 'Å': return 'Z'+1;
case 'å': return 'z'+1;
case 'Ä': return 'Z'+2;
case 'ä': return 'z'+2;
case 'Ö': return 'Z'+3;
case 'ö': return 'z'+3;
default : return ch;
}
}
int my_strcoll (char* p, char* q)
{
int pp, qq;
while (*p && (pp=collation_order(*p)) == (qq = collation_order(*q))) {
p++; q++;
}
return pp - qq;
}
Of course this means that non-alphabetic that come after Z/z in the ASCII table will get sorted incorrectly. If you want to sort those after Ö/ö, you need to extend collation_order accordingly. Try doing this without resorting to a case for each individual character.
Another way to write collation_order is to use character codes (cast to unsigned char) as indices in an array of 256 integer elements.
Also please note that old 8-bit encodings are old and should not be used for serious new development. For more information, read this.

Answer 2

Since your options are constrained and you can also constrain your input to a foreseeable universe, I'd suggest you to use a simple parser function to fit non-ASCII characters inside the places you know they should:
int parse_letter( int source )
{
switch( source )
{
case 'å':
case 'ä': return 'a';
case 'ö': return 'o':
// as many cases as needed...
default: return source;
}
}