Sorteren Sorteren door selectie

Sorteren
− Sorteren van gegevens is een veel voorkomende operatie.
− definitie sorteren : het herschikken van een gegeven verzameling objecten
zodat ze in een specifieke volgorde geplaatst worden.
− Een voorbeeld is een aantal getallen van klein naar groot sorteren.
− Meestal bestaat het object echter uit verschillende delen of velden. Het veld
waarop de sortering gebeurt, wordt sleutel genoemd.
− De verzameling objecten kan in een array zitten: interne sortering, omdat
de gegevens in intern (snel toegankelijk) RAM geheugen zitten.
− Wanneer de verzameling objecten als structures in een bestand zitten,
spreekt men van externe sortering.
− in situ sortering: zuinig omgaan met benodigde geheugenruimte: er wordt
geen tweede array gebruikt om het resultaat in te plaatsen; de elementen
worden in de gegeven array herschikt. worden.
− technieken via array van n integers: (het object bevat alleen de sleutel,
namelijk een geheel getal).
Sorteren door selectie
Het principe: kies het element met de kleinste sleutel en wissel dit met het
eerste element. Deze operatie wordt dan herhaald voor de overblijvende n − 1
elementen, dan met n − 2 elementen, enz.
Voorbeeld:
44 55 12 42 94 18 06 67
i = 1 06 55 12 42 94 18 44 67
i = 2 06 12 55 42 94 18 44 67
i = 3 06 12 18 42 94 55 44 67
i = 4 06 12 18 42 94 55 44 67
i = 5 06 12 18 42 44 55 94 67
i = 6 06 12 18 42 44 55 94 67
i = 7 06 12 18 42 44 55 67 94
De functie:
Voor i = 1, 2, 3, . . ., n − 1 doe
{
k is de index van het kleinste element uit {ai, . . .,an};
wissel ai en ak;
}
void s e l e c t i e ( int a [ ] , int n)
{
}
int i , j , k ;
int x ;
for ( i =1; i

Sorteren door invoegen
Het principe: de objecten zijn verdeeld in een doelreeks a1, . . .,ai−1 en een
bronreeks ai, . . .,an; in opeenvolgende stappen wordt het volgende element ai
van de bronreeks ingevoegd in de doelreeks.
Voorbeeld:
De functie:
44 55 12 42 94 18 06 67
i = 2 44 55 12 42 94 18 06 67
i = 3 12 44 55 42 94 18 06 67
i = 4 12 42 44 55 94 18 06 67
i = 5 12 42 44 55 94 18 06 67
i = 6 12 18 42 44 55 94 06 67
i = 7 06 12 18 42 44 55 94 67
i = 8 06 12 18 42 44 55 67 94
Voor i = 2, 3, . . ., n doe
{
x = ai;
voeg x in op de juiste plaats tussen {a1, . . .,ai};
}
void invoegen ( int a [ ] , int n)
{
int i , j ;
int x ;
for ( i =2; i 0 && x < a [ j ] )
extra test j > 0 wordt overbodig door gebruikt te maken van een sentinel,
door in a[0] de waarde van x te stoppen. Dit nulde element van de array
bevat toch geen element van de rij die moet gesorteerd worden.
De rij met de te sorteren getallen begint vanaf a[1].
Sorteren door wisselen
Het principe van bubble sort: vergelijk twee naast elkaar gelegen elementen;
indien ze niet in volgorde staan, wissel dan deze de elementen. Dit wordt
gedaan voor elk paar buren in de rij en het geheel wordt herhaald tot geen
enkel paar buren nog gewisseld wordt.
Voorbeeld:
44 55 12 42 94 18 06 67
i = 2 06 44 55 12 42 94 18 67
i = 3 06 12 44 55 18 42 94 67
i = 4 06 12 18 44 55 42 67 94
i = 5 06 12 18 42 44 55 67 94
i = 6 06 12 18 42 44 55 67 94
i = 7 06 12 18 42 44 55 67 94
i = 8 06 12 18 42 44 55 67 94

De functie:
void bubble( int a [ ] , int n)
{
}
int i , j ;
int x ;
for ( i =2; i=i ; j −−)
{
}
if ( a [ j −1] > a [ j ] )
{
}
x = a [ j −1]; a [ j −1] = a [ j ] ; a [ j ] = x ;
Een verdeel-en-heers techniek
Het principe: verdeel de verzameling objecten in twee delen en sorteer deze
twee delen onafhankelijk van elkaar.
Quicksort ( a, l, r)
{
indien meerdere elementen in {al, . . ., ar}
{
verdeel {al, . . .,ar} in een links en een rechts deel;
(gebruik makend van een pivot element)
Quicksort het linkse deel;
Quicksort het rechtse deel;
}
}
De verdeling moet gebeuren zodat
+ het pivot element ai bevindt zich op zijn uiteindelijke plaats i;
+ al de elementen in {al, . . .,ai−1} zijn kleiner dan of gelijk aan ai;
+ al de elementen in {ai+1, . . .,ar} zijn groter dan of gelijk aan ai.
Voorbeeld:
l
De functie:
(l+r)
2
r
1 4 8 44 55 12 42 94 18 6 67
1 2 3 6 18 12 42 94 55 44 67
1 1 2 6 12 18 42 94 55 44 67
5 6 8 6 12 18 42 94 55 44 67
7 7 8 6 12 18 42 44 55 94 67
6 12 18 42 44 55 67 94
void quicksort ( int a [ ] , int l , int r )
{
int i , j ;
int x , w;
i = l ;
j = r ;
x = a [ ( l+r )/2 ] ;
do
{
while ( a [ i ] < x )
i++ ;
while ( a [ j ] > x )
j−− ;
if ( i

}
}
}
w = a [ i ] ;
a [ i++] = a [ j ] ;
a [ j −−] = w ;
while ( i 1 )
else
n = atoi ( argv [ 1 ] ) ;
n = 10;
srand (1063);
for ( i =1; i

In volgende tabel is de gebruikte rekentijd weergegeven voor een aantal
verschillende n waarden:
n selectie invoegen bubble quicksort
128 3 2 3 2
256 8 6 12 3
512 25 17 40 6
1024 85 59 158 14
2048 316 214 580 29
4096 1234 797 2240 59
8192 4828 3122 8890 120
+ quicksort is duidelijk de snelste methode
+ bubblesort (klassiek voorbeeld in veel cursussen) de minst goede methode
Een generieke sorteerfunctie
De functie die de rangorde/volgorde van de elementen die moeten gesorteerd
worden bepaalt, wordt als actueel argument doorgegeven aan de
sorteerfunctie. In de sorteerfunctie is deze parameter een pointer naar een
functie. Om de gepaste kleiner dan relatie te bepalen, wordt met behulp van
deze pointer de juiste functie opgeroepen.
Deze functie heeft twee parameters, namelijk pointers naar de twee elementen
die met elkaar moeten vergeleken worden. De functie heeft als
terugkeerwaarde:
• -1 : als het eerste element kleiner is dan het tweede element;
• 0 : als het eerste element gelijk is aan het tweede element;
• 1 : als het eerste element groter is dan het tweede element.
Bijvoorbeeld wanneer de twee elementen pointers naar strings zijn, dan kan de
standaard bibliotheekfunctie int strcmp(const char ∗, const char ∗) als functie
gebruikt worden.
/*
* gensort : een generieke sorteerfunctie
*/
#include
#include
#define AANTAL 8260
#define GROOT 65535.0
typedef struct
{
} Blok ;
int x ;
int y ;
void s e l e c t i e ( Blok a [ ] , int b , int n , int (∗ vgl )( Blok ∗ , Blok ∗ ) ) ;
void druk( Blok a [ ] , int n ) ;
int vglx ( Blok ∗s , Blok ∗t ) ;
int vglf ( Blok ∗s , Blok ∗t ) ;
int main( int argc , char ∗argv [ ] )
{
Blok a [AANTAL] ;
int i , n = 10;
if ( argc > 1 )
n = atoi ( argv [ 1 ] ) ;
srand (n ∗1063);
printf (” %d \n” , rand () ) ;
for ( i =1; i

}
s e l e c t i e (a , 1 , n , vglx ) ;
druk(a , n ) ;
s e l e c t i e (a , 1 , n , vglf ) ;
druk(a , n ) ;
int vglx ( Blok ∗s , Blok ∗t )
{
}
if ( s−>x < t−>x )
return −1;
else if ( s−>x > t−>x )
else
return 1;
return 0;
int vglf ( Blok ∗s , Blok ∗t )
{
}
if ( ( float ) s−>x/s−>y < ( float ) t−>x/t−>y )
return −1;
else if ( ( float ) s−>x/s−>y > ( float ) t−>x/t−>y )
else
return 1;
return 0;
void s e l e c t i e ( Blok a [ ] , int b , int n , int (∗ vgl )( Blok ∗ , Blok ∗))
{
int i , j , k ;
Blok x ;
if ( b == n )
return ;
x = a [ b ] ; k = b ;
for ( j=b+1; j