Derde college complexiteit. 7 februari Zoeken

Maat: px

Weergave met pagina beginnen:

Download "Derde college complexiteit. 7 februari Zoeken"

Heidi Hendrickx
7 jaren geleden
Aantal bezoeken:

1 College 3 Derde college complexiteit 7 februari 2017 Recurrente Betrekkingen Zoeken 1

2 Recurrente betrekkingen -1- Rij van Fibonacci: 0,1,1,2,3,5,8,13,21,... Vanaf het derde element: som van de voorgaande twee Een recurrente betrekking is een voorschrift om een waarde T(n) te berekenen door middel van zijn voorganger(s), dus bijvoorbeeld T(n 1), of T( n 2 ), of... Voor de Fibonacci-getallen geldt: T(n) = 0 n = 0 1 n = 1 T(n 1)+T(n 2) n > 1 2

3 Recurrente betrekkingen -2- Een ander voorbeeld van een recurrente betrekking: T(n) = { 1 n = 1 2T( n 2 )+n n = 2k > 1 Strategie: herhaalde substitutie en afleiden algemene vorm, of: Probeer wat termen door te rekenen: zie je een patroon? Bewijs de formule met volledige inductie Oplossing: T(n) = n+nlgn Θ(nlgn) 3

4 Recurrente betrekkingen -3- De vorige recurrente betrekking, maar nu voor algemenere n, dus niet alleen voor tweemachten: T(n) = { 1 n = 1 2T( n 2 )+n n > 1 Dan geldt: T(n) O(nlgn) (en overigens ook T(n) Θ(nlgn)). Dit kan bewezen worden door met behulp van volledige inductie bijvoorbeeld aan te tonen dat T(n) 2nlgn voor alle n 2. 4

5 Recurrente betrekkingen -4- En ten slotte nog twee voorbeelden om op te lossen. (i) T(n) = { 3 n = 1 T(n 1)+n 1 n > 1 Oplossing: T(n) = n(n 1) (ii) T(n) = { 0 n = 1 2T( n 4 )+ n n = 4 k > 1 Oplossing: T(n) = nlog 4 n = 1 2 nlgn 5

6 Verder vandaag We bekijken een aantal zoekalgoritmen, waarvan we de complexiteit vergelijken. Met behulp van beslissingsbomen bewijzen we later een ondergrens op de complexiteit. Zoeken met behulp van sleutelvergelijkingen Zoekalgoritmen: Ongeordend Lineair zoeken (opgave 3) Geordend Lineair zoeken (opgave 4) Jump Search Binair Zoeken (opgave 5) 6

7 Zoeken Probleem Gegeven een waarde X en een array A, bestaande uit n elementen A[1],...,A[n]. Bepaal of X in A zit. Zo ja, geef de index terug, zo nee, geef -1 terug. We maken gebruik van sleutelvergelijkingen van de vorm: of if (X = A[i]) then // binaire vergelijking gevonden; else...; if (X = A[i]) then // drie-weg vergelijking gevonden; else if (X < A[i]) then...; else...; 7

8 Sleutelvergelijking Een sleutelvergelijking doet voor iedere aanroep maximaal twee ja/nee vergelijkingen Kost dus Θ(1) tijd per aanroep De drie-weg vergelijking kost in orde van grootte evenveel tijd als de vergelijking (X = A[i]) We tellen beide soorten sleutelvergelijkingen dan ook als één vergelijking 8

9 Ongeordend lineair zoeken Probleem Zoek X in een willekeurig array A = A[1],...,A[n]. Complexiteit van het probleem (opgave 3.e.) Elk algoritme dat een waarde X zoekt in een (willekeurig) array A met n elementen, en dat alleen gebruik maakt van sleutelvergelijkingen (X =,< A[i]), doet in de worst case ten minste n vergelijkingen. Algoritme en complexiteit Lineair zoeken doet in de worst case n vergelijkingen, en is dus optimaal. In het bewijs wordt expliciet gebruikt dat je geen informatie hebt over de invoer, behalve wat je uit de sleutelvergelijkingen leert. 9

10 OLZ: algoritme Algoritme (zie opgave 3): (1) index := 1; (2) while index n and A[index] X do (3) index := index+1; (4) od (5) if index n then (6) return index; (7) else (8) return 1; (9) fi basisoperatie 10

11 OLZ: complexiteit Best case Je kunt al bij de eerste vergelijking prijs hebben: Θ(1) Average case Laat q de kans zijn dat X in A voorkomt Iedere positie in A is even waarschijnlijk Dan worden er in de average case q 1 2 (n+1)+(1 q) n Θ(n) sleutelvergelijkingen gedaan Worst case Als X niet in A zit of helemaal achteraan: Θ(n) 11

12 Geordend lineair zoeken Probleem Zoek X in een oplopend gesorteerd array A, bestaande uit n elementen A[1],...,A[n]. Algoritme: (1) index := 1; (2) while index n and A[index] < X do (3) index := index+1; (4) od (5) if index n and X = A[index] then (6) return index; (7) else (8) return 1; (9) fi basisoperatie 12

13 GLZ: complexiteit De complexiteit van geordend lineair zoeken. Worst case: n sleutelvergelijkingen (Bij welke invoer gebeurt dit? En bij ongeordend zoeken?) Average case: n 2 + n n+1 +q (1 2 n n+1 ) Θ(n 2 ), met q de kans dat X in A voorkomt, en: 1. als X in A: alle n posities in A even waarschijnlijk 2. als X niet in A: alle n+1 gaten even waarschijnlijk zie ook opgave 4 13

14 Jump search A is weer oplopend gesorteerd; kies k met 1 k < n index := k; // index is altijd een k-voud // vergelijk X met A[k],A[2k],A[3k],... while index n and A[index] < X do index := index+k; od if index n // A[index k] < X A[index] lineair zoeken van X in A[index k +1]...A[index]; else // A[index k] < X A[n] lineair zoeken van X in A[index k +1]...A[n]; fi 14

15 JS: complexiteit Worst case: n +k sleutelvergelijkingen k Beste keus: k = n. Dan doet Jump sort in het slechtste geval Θ( n ) sleutelvergelijkingen. Dat is beter dan geordend lineair zoeken. Vraag: kan zoeken in een geordend array nog beter? Antwoord: Ja, namelijk binair zoeken. 15

16 (Werk)college - Volgende college: dinsdag 14 februari, 11:15 13:00, zaal Eerste werkcollege: dinsdag 7 februari, 13:45 15:30, zaal 405, liacs.leidenuniv.nl/ graafjmde/comp/ 16

Vergelijkbare documenten

Vierde college complexiteit. 16 februari Beslissingsbomen en selectie

Vierde college complexiteit. 16 februari Beslissingsbomen en selectie Complexiteit 2016/04 College 4 Vierde college complexiteit 16 februari 2016 Beslissingsbomen en selectie 1 Complexiteit 2016/04 Zoeken: samengevat Ongeordend lineair zoeken: Θ(n) sleutelvergelijkingen