Insertion: neem item, kijk waar het moet tussengeplaatst worden Selection: neem grootste->1, 2 e grootste->2 Bubble: vergelijk en wissel om

Transcriptie

1 LES 1 Quick Find Array: verbonden indien index gelijk F: cst U: N Quick Union Boom: verbonden indien root gelijk F: kan N, kan M N/2 U: cst Weighted Quick Union boom+lengte: verplaatst kleinste boom perf: M lgn Path compression -> vlakke boom LES 2 Geïndexeerde structuren (snel bepaald element vinden) Gelinkte lijsten (snel toevoegen/verwijderen) Lineair, circulair, dubbelgeschakeld Basisoperaties Afsluiten: null ptr, dummy node Samengestelde structuren Multilijst Graaf (mem : adj matrix: V² # adj list: V x E) Boomstructuren LES 3 Access specifiers Private, public, protected, friend Templates Scoping/type regels + error check door compiler Andere mechanismen: ptr (casting), typedef (bestaan bewerkingen?), macro s (geen compiler check Generalised queues Operaties Soorten: afh v eisen insert/remove en implementatie (tabel/list) FIFO: push, pop LIFO: put, get Andere: random queue, deque, priority queue, symbol table C++ container classes (o.m. Vector) First Class ADT Gebruik = ingebouwd type VW : copy constr, destr, op= Operator overloading (member globale ftie)

2 LES 4 Recursie (opsplitsen in meerdere eenvoudige deelprobl, bv fact) Divide et impera (helft vd data) Torens van Hanoi Dynamisch programmeren Prob: afhankelijke subproblemen (bv fibonacci) Opl: bottom-up programmeren (kleinste waarde eerst, opslaan) Top-down: vermijd herberekening Boomstructuren en grafen Toepassingen (dirs, games, dns, voorstelling algoritmes) Statisch dynamisch Index gelinkt Definities (internal/external node, branch M-ary tree Hanoi: stackdiepte = hoogte boom Doorlopen: Bomen: Pre(bv stack)/in/post/level(bv queue)-order Grafen: DFS (game tree, backtracking) [recursief] LES 5 BFS [queue] Gemakkelijke operaties: onderaan toevoegen/verwijderen 2 bomen samenvoegen Insertion: neem item, kijk waar het moet tussengeplaatst worden Selection: neem grootste->1, 2 e grootste->2 Bubble: vergelijk en wissel om V=vgln T=toekenningen Insertion sort V: N²/4 T: N²/4 Indien al redelijk gesorteerd Selection sort V: N²/2 T: N Grote data-items, kleine keys (T minimaal) [onafh v hoeveel reeds gesorteerd] Bubble sort V: N²/2 T: N²/2 Quicksort: partitieelement op goede plaats, dan 2 helften Worst case: T: N² (al gesorteerd) Best case: T: N lg N (helften +- gelijk) Optimalisatie Vanaf ondergrens overhead vermijden door bv insertion sort Median-of-3 pivot (=> worst case onwaarschijnlijk) Mergesort: verdeel in 2, sorteer helften recursief, voeg samen in volgorde Bottleneck: samenvoegen Tijd: altijd N lg N (ongeacht worst/best/average case) Kost: ruimte voor merge (~N) Besluit: goed algoritme beter/goedkoper dan superpc

3 LES 6 Priority Queue PQ (records met sleutel) Operaties: insert / getmax Toep: scheduler, sims, fraudedetectie (enkel naar grootste waarden kijken) Implementatie: tabel gelinkte lijst, wel/niet in volgorde Prestaties (tabel en LL) Insert Getmax In volgorde N 1 Niet in volgorde 1 N We zouden graag zelfde efficiëntie hebben bij insert/getmax Heap (sleutel root >= sleutel children) Implementatie: array Algoritmes: herstel heapvoorwaarde: fixup en fixdown Insert: onderaan bijvoegen en fixup Getmax: exchg(root,eindknoop) en fixdown(nieuwe root) Prestaties: insert & remove: lg N Heapsort Algoritme: insert alles, dan getmax alles Triviale implementatie: niet effeciënt Extra copy data N opeenvolgende inserts Opl: fixdown/up rechtstreeks toepassen Optimaal voor tijd én ruimte: O(N lg N) (altijd) Mergesort: mem O(N) Quicksort: worstcase O(N²) LES 7 Symbol Table ST (elementen met sleutels) Operaties: insert/search Toep: telgids, compilers, dns Zoeken op key index (M keys): insert/search: O(1) N <= M Duplicate keys => hashing Sequentiëel zoeken Prestaties: worst/avg case, search hit/miss worst avg Search Insert Delete Search Insert delete Ongesorteerde N 1 1 N/2 1 1 array Gesorteerde array N N N N/2 N/2 N/2

4 Binair zoeken Gesorteerde array, 2 helften -> divide et impera Cn= Cn/2 + 1 Search: O(lgN) Insert: O(N²) => opl via BST (bruikbaar voor statische data waar bijna geen insert s zijn) Binary Search Tree BST Definitie: keys linkse subtree <= root <= keys rechtse subtree Search: recursief (vgl binair zoeken), stop bij hit of lege subboom Insert = zoeken en toevoegen bij miss Gesorteerd: BST in order overlopen Vgl quicksort: partitie-element= root Prestaties: Willekeurige invoer Worst case Search lg N N Insert lg N N Verbetering: ook lg N bij worst case en remove (cfr infra) Toepassing: keyword search (werken met indices) Root insertion: nieuwste element wordt root Nut: korte accesstime voor recente knopen Hoe: onderaan toevoegen, door rotaties naar boven Remove/delete Bv root verwijderen: Rechtersubtree, kleinste key->nieuwe root, linkersubtree eraanplakken OF Linkersubtree, grootste key->nieuwe root, rechtersubtree eraanplakken boom niet langer willekeurig! Join Alles van 1 bij 2 inserten: eenvoudig, maar niet lineair Merge: vereist extra ruimte voor tabel Root insertion: O(N) Root 1 inserten bij 2 2 subtree s kleiner/groter nieuwe root Join op 2 subbomen (recursie)

5 LES 8 Randomized Trees Probleem bij BST: bij worst case: invoer O(N²), search O(N) Enkel bij willekeurige invoer elke knoop kans 1/(N+1) om root te worden Opl: garandeer nieuwe knoop kans 1/(N+1) om root te worden Kost: extra veld om #knopen N bij te houden Tijd voor randomgeneratie Winst: boom is steeds gebalanceerd -> insert/search/delete O(lgN) Invoer: rand() < RAND_MAX / (N+1) -> root insert Join: A (M) & B (N) -> kans M/(N+M) en N/(N+M) dat A resp. B nieuwe root Delete: statistisch welke subtree je bij welke voegt Splay Trees (insert BST O(N²) verlagen) Doel: boom die zichzelf reorganiseert na operatie Hoe: insert/search van x => x naar de root door dubbele rotaties Prestaties: (amortised: doe nu iets meer dan gevraagd om later werk te besparen) N operaties O(N lg N) 1 operatie kan O(N) M insert/seach in tree met N keys: totaal O( (N+M) lg(n+m) ) Gebruik: kleine workingset (veel naar zelfde zoeken->staat dicht bij root) bomen Met 2/3/4 links en 1/2/3 keys Insert: eerst search miss, dan 2knoop->3,3->4,4 opsplitsen Transformeren tijdens afdaling -> onderste!= 4knoop Balans altijd behouden Hoogte: worst case lg N (alles 2knoop), best case: ½ lg N (alles 4) Implementatie complex: verschillende datatypes voor knoop Splitsen 4 knoop Juiste verbinding vinden Rood-zwart bomen Abstractie voor implementatie bomen BST met extra veld, interne verbinding: zwart, ext: rood Beste 2 werelden: Splitsen 4kn 2kn: kleuren wisselen 3kn, lange verbinding: idem Ander: rotatie + kleuren wisselen Toep: map, multimap, multiset snel zoeken (BST) Blijft gebalanceert (2-3-4), minder rot dan dan splay tree

6 LES 9 Hashing: tabel met key-index Index = ftie(key); ftie = hashfunctie Tijd space tradeoff: sleutel = index sequentiëel zoeken Random index: sleutel->geheel getal, h(k) = k mod M (M=priem) Lange sleutels: methode van Horner (past niet in geheugen anders) h = a*v+h universele hashftie: a=pseudorandom insert/search: O(1), sorteer slechte performantie Collision resolution: 2 keys => zelfde index Separate chaining: gelinke lijsten (dynamisch geheugen) M<N N/M sleutels per lijst Toegang tabel: O(1), insert in LL: O(1) M = N/10, zoeken/insert O(1) Zoeken/sorteren(nog te doen hier): in gelinkte lijst: cfr supra Eenvoudig te implementeren Open adres schema (lineaire probes) M>N Invloed van clusters M= 2N: zoeken/insert O(1) Sorteren moeilijk Double hashing 2 e TF -> sprongwaarde voor probefunctie (wel extra kost) => clusters worden vermeden (sleutels die conflicteren hebben verschillende sprongwaarde) Nadeel: delete is complex (bv delete element dat zorgde dat ander op offset terechtkwam -> lege positie -> ander element wordt niet gevonden) Opl: vervang element door dummy-element of herorganiseer tabel Niet indien sorteren nodig