Hej!
Jag undrar hur jag ska göra för att sortera en lista som innehåller struktar. Struken innehåller Person.fNamn och Person.eNamn. Så jag skullle vilja sortera i bokstavsordning på eNamn.
Någon som är duktig på det kanske skulle kunna skriva ihop en kod som beskriver det.
//
Fredrik

Det var så längesen jag höll på med C så jag var tvungen att testa om jag fixade det.

Vet inte riktigt om detta är den lösning du är ute efter, men den fungerar :)

<code>
#include <stdio.h>
#include <string.h>

struct person{
char fNamn[20];
char eNamn[20];
};

void main(void) {
struct person personer[4], tmpPersoner;
int i,j;

strcpy(personer[0].fNamn,"Kalle");
strcpy(personer[0].eNamn,"Kula");
strcpy(personer[1].fNamn,"Egon");
strcpy(personer[1].eNamn,"Egonson");
strcpy(personer[2].fNamn,"Kullagulla");
strcpy(personer[2].eNamn,"Andersson");
strcpy(personer[3].fNamn,"Urban");
strcpy(personer[3].eNamn,"Bengtsson");


printf("-- Osorterad --\n");
for (i=0;i<=3;i++){
printf("%s, %s\n",personer[i].eNamn,personer[i].fNamn);
}


for(i=0;i<4;i++){
for(j=i+1;j<4;j++){
if(strcmp(personer[i].eNamn,personer[j].eNamn) > 0){
tmpPersoner=personer[j];
personer[j]=personer[i];
personer[i]=tmpPersoner;
}
}
}

printf("-- Sorterad --\n");
for (i=0;i<=3;i++){
printf("%s, %s\n",personer[i].eNamn,personer[i].fNamn);
}
}

</code>

Fredrik

Nu bad han iofs om en quicksort-algoritm. Det du har beskrivit är vad jag kan se selection-sort som har en komplexitet på O(n^2) vilket inte är bra. Om antalet saker som ska sorteras är större än några få bör man byta sorteringsalgoritm till en med komplexitet O(n log n), exempelvis quicksort, mergesort eller heapsort.

I quicksort algoritmen jobbar man rekursivt (devide and conquer) och börjar i varje steg med att välja ett element som ska vara avdelare. Sen lägger man det först i listan och ser till att alla tal som är mindre än eller lika med det hamnar i listans första del, dock inte i inbördes rätt ordning. Sen sorterar man delen med små tal och den med stora tal var för sig med quicksort tills man bara har ett tal kvar eftersom ett tal alltid är sorterat. Därefter är det bara att slå ihop listorna.
Quicksort har mycket bra komplexitet i genomsnitt men kan ha O(n^2) OM det tal man väljer som avdelare alltid är det sämsta. Om man är intresserad av en bättre värsta falls-körtid bör man använda merge- eller heapsort istället.

Om det du ska koda inte är del av en labb-uppgift så att själva meningen är att konstruera en quicksort eller om du inte är väldigt nyfiken på att skriva en själv tycker jag att du ska titta på sort-algoritmen i standard-biblioteket. Den metod som heter sort använder sig av quicksort i de flesta implementationer.

/Per