1 Datastructuren Sorteren: alleen of niet alleen vergelijkingen (II) College 6

2 Vergelijkingsgebaseerde algoritmen  Enige operaties op objecten zijn:  A[i] A[j]; A[i]  A[j]; A[i]  A[j]; A[i]==A[j]  Verplaatsingen  Voorbeelden: Quicksort, Randomized Quicksort, Heapsort, Bubblesort, Insertionsort, …  Allemaal gebruiken ze (n log n) tijd:  (n log n) worst case: Heapsort (…)  (n 2 ) worst case, (n log n) gemiddeld: Randomized Quicksort  (n 2 ) worst case en gemiddeld: Bubble sort

3 Vorige keer  Een aantal algoritmen die NIET vergelijkingsgebaseerd zijn:  Counting sort  Radix sort  Bucket sort  Deze gebruiken eigenschappen van de waardes: kijken binnenin de waardes  Zijn dan – als die eigenschappen gelden – sneller: O(n) tijd (worst case, verwacht, …)  Werken dus alleen zo snel als die eigenschappen gelden!!!

4 Vandaag  Ondergrens voor vergelijkings-gebaseerd sorteren (comparison sorts)  Vandaag Datastructuren

5 De vraag  Vraag: zouden er sorteeralgoritmen die minder dan (n lg n) tijd gebruiken?  O(n), O(n lg lg n), O(n  (lg n)) ?  Het antwoord is JA en NEE  JA – als we extra aannamen kunnen maken over de input en die gebruiken  NEE – als we dat niet kunnen Datastructuren

6 ONDERGRENZEN VOOR SORTEREN Vijf Datastructuren

7 Vergelijkingsgebaseerd sorteeralgoritme (herhaling)  In een vergelijkingsgebaseerd sorteeralgoritme (comparison sort) zijn de enige operaties die op de data worden uitgevoerd:  Vergelijkingen: A[i] A[j]; A[i]  A[j]; A[i]  A[j]; A[i]==A[j]  Verplaatsingen  De data worden verder niet bekeken om extra informatie er uit te halen waar we de loop van het programma mee beïnvloeden Datastructuren

8 Allemaal verschillende elementen  We bewijzen: vergelijkingsgebaseerde algoritmen moeten op sommige inputs lg(n!) = (n lg n) vergelijkingen doen  We nemen in het bewijs aan dat alle elementen in de array (van lengte n) verschillend zijn  Algoritme moet immers dan ook correct werken Datastructuren

9 De stelling Stelling Voor ELK vergelijkingsgebaseerd algoritme A: er is een constante c, zodat voor elke n er een input met n elementen is waar A cn lg n vergelijkingen uitvoert (en dus kost A n lg n) tijd)

10 Model van algoritme: Beslissingsboom  Binaire boom, met  Elke knoop heeft twee of nul kinderen  Elke interne knoop is gelabeld met een vergelijkingstest: welke twee (verschillende) elementen (uit oorspronkelijk array) worden met elkaar vergeleken?  Links: als 1 e element het kleinste is  Rechts: als 2 e element het kleinste is  Bij een blad... Tja … wat doen we daar? Datastructuren

11 Beslissingsboom voor Insertion Sort op 3 elementen Datastructuren INSERTION-SORT(A) for j = 2 to lengte(A) do key = A[j] i = j – 1; while i > 0 and A[i] > key do A[i+1] = A[i] i = i – 1; A[i+1] = key 1:2 2:3 1:3 2: In de bladeren staan voorbeelden van inputs die daar terecht komen

12 Bladeren gemarkeerd met een permutatie Datastructuren 1:2 2:3 1:3 2:3 {1,2,3} {1,3,2}{2,3,1} {2,1,3} {3,1,2} {3,2,1}

13 Over beslissingsbomen  Als twee inputs dezelfde ordening hebben, komen ze in hetzelfde blad  Bijvoorbeeld: (4,6,5) of (10, 30, 20) of (2, 47, 42)  Er kunnen testen zich herhalen (bijvoorbeeld in bubble sort)  Er kunnen bladeren zijn waar je nooit terecht kan komen (komt ook in bubble sort voor)  Niet zo belangrijk hoe je precies test (i<j of j<i) etc.  Markeer bladeren met de permutaties die daar terecht komen

14 Hooguit één permutatie in een blad  Als twee inputs in hetzelfde blad terecht komen, worden dezelfde data-bewegingen uitgevoerd  De inputs worden op dezelfde manier gepermuteerd!  Prima, als we dezelfde sortering op de inputs hebben (als {4,6,5}, {1,3,2} of {12, 49, 25})  Niet prima, als de inputs anders gesorteerd zijn: want dan is minstens één antwoord fout  In elk blad van de boom staat hooguit één permutatie van {1,2,3,…,n} Datastructuren

15 Diepte van beslisbomen versus vergelijksgebaseerd sorteren  Elke permutatie moet voorkomen in een blad van de beslisboom  Elk blad van de beslisboom heeft hooguit 1 permutatie  Als er een permutatie in een blad met diepte r zit moeten voor die permutatie r vergelijkingen worden uitgevoerd  Er zijn n! permutaties  Diepte van een boom met n! bladeren is ondergrens voor vergelijkingsgebaseerd sorteren

16 Diepte van beslisboom  Als een binaire boom diepte r heeft, heeft de boom maximaal 2 r bladeren  Bewijs met inductie naar r. Triviaal als r=0; als r>0, dan wortel heeft twee kinderen met bomen met diepte r-1, dus 2 r r-1 bladeren  Een beslisboom voor sorteren van n elementen heeft minstens n! bladeren, dus heeft diepte minstens lg(n!) = (n lg n)  lg(n!) < lg(n n ) = n lg n  lg(n!) > lg((n/2) n/2 ) = n/2 * (log n/2) = n/2 * (log n – 1) = (n lg n) Want n! > n/2 * (n/2+1) * … * (n-1) * n > (n/2) n/2 Datastructuren

17 Stelling  Stelling: Elk vergelijksgebaseerd algoritme gebruikt voor sommige inputs van lengte n (n lg n) vergelijkingen en dus (n lg n) tijd.  Gevolg: heapsort en merge sort zijn “asympthotisch optimaal”. Datastructuren

18 CONCLUSIES Vijf Datastructuren

19 Sorteren  Zonder gebruik te maken van speciale eigenschappen van input: (n lg n)  Ondergrensbewijs: aantal vergelijkingen  Met gebruik van speciale eigenschappen:  Sneller, vaak O(n) Counting Sort Radix Sort Bucket Sort  Maar natuurlijk alleen voor inputs die zulke eigenschappen hebben

20 Conclusies  In de praktijk worden soms hybride methodes gebruikt  Uiterst slimme methoden om heel weinig elementen zo snel mogelijk te sorteren  Overstappen van ene sorteermethode naar andere ergens gedurende algoritme  Voor implementatie van sommige van deze algoritmen (en voor heel veel andere toepassingen) hebben we lijsten nodig  Later kijken we naar implementaties van lijsten en speciale versies: queues en stacks