Transcript Powerpoint file - Universiteit Utrecht

Datastructuren en Algoritmen
Datastructuren
college 1
Vandaag
•
•
•
•
•
•
Organisatie vak
Inleiding practicum
Wat en waarom: datastructuren en algoritmen
Voorbeelden van datastructuren en algoritmen
Binary search
Analyse van algoritmen 1
Datastructuren
Docent
• Hans Bodlaender
• Hoofddocent, vakgebied: Algoritmiek – netwerken en
grafen
• Kamer 5.03, BBL 030-2534409
• [email protected]
• Spreekuren:
– Woensdag 15.15 – 17.00
– Vrijdag 13.00 - 15.00
Datastructuren
Onderdelen
•
•
•
•
•
College: zeer belangrijk (powerpoints komen op website)
Werkcollege: onmisbaar
1e deeltentamen: ongeveer helft stof, 35% eindcijfer
2e deeltentamen: andere helft stof, 40% eindcijfer
Practicum: acht programmeeropgaven: domjudge systeem; eerste telt
voor 0,2 punt; elke andere voor 1,4 punt; minstens 5 goed.
• Eindcijfer:
– 35% eerste deeltentamen, 40% tweede deeltentamen, 25% practicum
– Practicum moet voldoende zijn (5 uit 8 gehaald)
• Werkcollege: semi-verplicht
– Geen herkansing/aanvullende toets als je meer dan drie keer afwezig was
Datastructuren
Werkcollege
•
•
•
•
•
ONMISBAAR!
Verplicht: nodig voor recht op aanvullende toest
Maar nog veel nodiger voor het beheersen van dit vak!
Actieve deelname wordt genoteerd
Vier groepen:
– Drie “gewone”, grotere groepen: wo 11 – 13; vrij 11-13
– Groep 4: wo 15-17, vrij 11-13
• Indeling: zoek zelf een zaal
– Ga liever alleen naar groep 4 als je wo 11-13 niet kan want anders
is deze snel vol
Practicum
• Begin op tijd
• Maak het werk alleen.
Fraude wordt gemeld aan de examencommissie 
• Opgaven staan op website van vak
• Inleveren via domjudge systeem
• C#; studenten CKI mogen ook Java gebruiken
• Acht opdrachten
• Latere opdrachten zijn wat lastiger dan eerdere en vaak meer werk
• Opgave 1 is erg makkelijk : om systeem te leren kennen (0,2 punt)
• Andere opgaven tellen even zwaar (1,4 punt)
• Opdracht is: Gehaald (10) of Niet Gehaald (0).
Datastructuren
Becijfering practicum
• Meestal zal een ingeleverd programma dat door domjudge
geaccepteerd wordt een 10 opleveren voor dat programma
• Er is echter nog een laatste inspectie, waarbij gekeken wordt of aan de
opdracht is voldaan
• Je kan echter zelf wel “aanvoelen” of er een probleem is
• Voorbeelden waarin een gehaald in een niet gehaald kan veranderen:
– Opgave 3 vraagt om een hybride vorm van randomized quicksort en
insertion sort, maar je gebruikt mergesort:
– Je gebruikt een java-library voor sorteren, terwijl gebruik van zo’n library
niet is toegestaan
• Het is goed te doen om een 10 te halen voor het practicum
Practicum
• Systeem weigert inzendingen die:
–
–
–
–
–
Niet compileren
Op geheime testinvoeren foute uitvoer geven
Op geheime testinvoeren te langzaam zijn
Niet in C# geschreven zijn
En vertelt welk van deze redenen voor je programma geldt
• Als geweigerd: verbeter je programma en probeer opnieuw
tot het werkt!
• Je leert ook belangrijke algoritmen en datastructuren: helpt
(bij je latere carrière en bij het tentamen)
• Extra uitleg straks door Sander vd Hurk
• Vragen: vragenuur of (met mate:) via clarifications
Belangrijk
• Merk op: je moet het practicum alleen doen!!!!
• Dus niet in groepjes van 2 personen
• Fraude en plagiaat wordt streng bestraft EN gemeld aan de
examencommissie
• Deel je tijd goed in: je kan al eerder (nu) beginnen met de
meeste opgaven
• Te laat is te laat 
• Vragen over practicum:
– Inhoudelijk: op werkcollege, vragenuur, met mate:
clarifications
– Inloggen: Ruud Koot
– Cijfers, nakijken, deadlines: Steven Woudenberg
Fraude / plagiaat
• In gevallen van vermoeden van fraude worden
– De betreffende studenten uitgenodigd voor een gesprek
– Indien vermoeden niet weggenomen, wordt dit vermoeden
doorgegeven aan de examencommissie
– De examencommissie beslist of er sprake is van fraude en stelt een
staf vast
• In elk geval een berispring
• Regelement schrijft voor dat een 2e berisping automatisch een jaar
schorsing van de Universiteit Utrecht betekent
• Daarnaast: 0 voor de opgave in kwestie, mogelijk verdere uitsluiting
van Datastructuren voor dit jaar, of andere sanctie
Nooit doen!
• Code van andere studenten bekijken voor je
je eigen opgave hebt ingeleverd
• Je eigen code aan andere studenten geven
voor het verstrijken van de inleverdeadline
• Code van iemand anders op je eigen
account submitten
• ...
Wat wel mag
• Praten over opgaven zonder code te
bekijken
• Gebruik maken van (pseudo)-code uit het
boek
• ...
Meer over het practicum
• Straks voordracht van Sander van der Hurk
over het practicum (na de pauze)
• Vragenuur over practicum: woensdag van
10 tot 10.45 in BBL 103 CLZ
Programmeerwedstrijd
•
•
•
•
•
Georganiseerd door A-Es2
Leuk!
Spannend!
Leerzaam!
Bonuspunten (tot 0,6 als voldoende, tot 0,2 voor
recht op herkansing)
• Je kan wat winnen!
• Datum: wordt nog bekendgemaakt
Aanvullende toets
• Alleen als je vaak genoeg meegedaan hebt
aan werkcollege
• Alleen als gemiddeld eindcijfer minstens 4
is (3.8 bij een muKP-bonus)
• Er zijn:
– Schriftelijke aanvullende toets (“hertentamen”)
– Practicum (negende opgave)
• Details: zie website
Data
•
•
•
•
1e deeltentamen: woensdag 21 mei 2014
2e deeltentamen: vrijdag 4 july 2013
Programmeermiddag A-Es2 : wordt nog bekendgemaakt
Aanvullende toets (“hertentamen”): do 14 augustus (zo
vroeg vanwege BSA)
• Practicum: bijna wekelijkse deadlines, meestal woensdags,
zie opgaven
– 1e deadline (Een hoger salaris / een hogere score): woensdag 30
april, 23.59 uur
– 2e deadline (Levelzoeker): woensdag 7 mei , 23.59 uur
Diagnostische toetsen
• In sommige werkcolleges wordt een diagnostische toets
gehouden
• Soort minitentamen, wat je zelf nakijkt, aan de hand van
wat de werkcollegeleiding op bord voordoet
• Telt niet mee voor cijfer, maar laat jezelf zien hoeveel van
de stof je snapt/kan
Vragen stellen
In het college
In de pauze en
na afloop
Docent
Ja
Ja
Buurman
Nee
Ja
Of tijdens het
werkcollege
Datastructuren
Vragen
• Over de stof:
– Gedurende het college (domme vragen bestaan niet) aan docent
– In de pauze of na afloop van het college
– Aan werkcollegeleiders of studentassistenten in het werkcollege
• Over het practicum
– Per email aan de practicumleider (Steven Woudenberg)
– In het werkcollege aan de practicumleider of werkcollegeleiders
– Tijdens het vragenuur voor het practicum
• Over de werkcollegeopgaven
– In het werkcollege
• Over de tentamens en cijfers
– Aan docent: pauze, na afloop college, email, telefoon
Datastructuren
Rondvraag?
• Vragen over de organisatie?
• Collegeresponsgroep?
Algoritmen en datastructuren:
waarom?
• Iedereen is ongeduldig, want we willen
– Dat onze routeplanner snel vertelt welke kant we opmoeten (en
niet pas nà het kruispunt)
– Vloeiende beelden in het computerspel
– Niet een eeuw (of een week) wachten op de planning voor morgen
– …
• Dus: de computer moet alles snel uitrekenen
• Hoe doet ie dat? Met een goed algoritme en een goede datastructuur!
Datastructuren
Algoritme
• Methode om iets uit te rekenen – vgl. recept uit kookboek
• Naam komt van
– Muḥammad ibn Mūsā Abū Ǧa’far al-Ḫawārazmī
– Of: Al-Khwarizmi
– Schreef boek in 820 over oplossen van lineaire en kwadratische
vergelijkingen (“Algebra”)
– Misvatting van vertaler die titel en auteur
door elkaar haalde
Datastructuren
Datastructuur
• Manier om gegevens op te slaan (in computer)
• Helpt om algoritmen sneller te maken
• In dit college zullen we allerlei belangrijke datastructuren
bekijken
– Hoe zitten ze in elkaar?
– Hoe werken algoritmen op/met deze datastructuren?
– Hoe snel gaat dit?
Datastructuren
Algoritmisch Wedstrijdje
• Wat is de missende kaart?
• Twee vrijwilligers gezocht!
Datastructuren
Voorbeelden van algoritmische
vragen
•
•
•
•
•
•
Sorteren van rij getallen
Uitrekenen van oplossing wiskundig probleem
Berekenen van kortste route in netwerk
Zoeken van relevante webpagina’s bij een zoekterm (zoekmachine)
Compileren van C++-programma
Tonen van 2d-afbeelding aan de hand van 3d-model
In dit vak maken we een begin met de theorie.
Veel van deze vragen komen in
andere/vervolgvakken aan de orde!
Datastructuren
Onderwerpen uit dit vak
•
•
•
•
•
•
•
•
•
Analyse van algoritmen
Gelinkte lijsten; stacks & queues
Sorteren (op allerlei manieren)
Bomen: zoeken, doorlopen; binaire bomen; snelle zoekbomen
Dictionaries; Maps
Hashing
Priority queues
Tries
…
Datastructuren
Analyse van algoritmen (en
datastructuren)
• Twee vragen:
– Is het correct?
– Hoeveel tijd gebruikt het?
• Meten we in stappen
• O-notatie wordt veel gebruikt
• Als ‘t vandaag wat vaag is: we moeten beginnen met wat (saaie)
theorie; de leuke* algoritmen en datastructuren komen straks
*= vind ik
Datastructuren
Beschrijven van algoritmen met
Pseudocode
• Pseudocode: niet echt een programmeertaal
– Lijkt wat op code in een imperatieve taal
• Waarom pseudocode:
– Echte programmeertaal: veel extra commando’s die begrip
verduisteren
– Natuurlijke taal: niet precies genoeg
– Niet zo moeilijk om te zetten naar code in Java, C++, C#, Pascal,
…
• Imperatief versus functioneel:
– Sommige behandelde algoritmen/datastructuren makkelijk om te
vormen naar functionele taal; soms is dat lastiger
Datastructuren
Probleem 1: Zoeken in een rij
• Ook nuttig voor practicumopgave 2
• Gegeven: array A[1 … n] met n getallen,
een waarde x
• Gevraagd:
– Zit x in het array en zo ja, op welke positie?
Voorbeeld Pseudocode:
zoek een element in een array
ZOEK-ELEMENT(x,A)
{Input: Een element x en een array A (A loopt van 1 tot lengte(A))}
{Output: Een index i zodat A[i] = x of 0 als geen element in A gelijk is aan x}
i = 1;
while i  lengte(A) do
if (x = = A[i]) then return i
else i = i + 1;
endif
enddo;
return 0
Datastructuren
Over dit algoritme
• Als het element er niet in zit moet je n
vergelijkingen doen
• Als het element er wel in zit:
– In het slechtste geval: n vergelijking
– In het beste geval: 1 vergelijking
– Gemiddeld ongeveer n/2 vergelijkingen
• Kan beter door gebruik te maken van
sortering: binary search
Binary search (“Binair zoeken”)
• Als de rij getallen gesorteerd is kan het sneller met
een simpel maar belangrijk principe: binary
search
• Dus: neem aan:
A[1]  A[2]  A[3]  …  A[n-1]  A[n]
Binary search
• Idee: houdt twee variabelen bij onder en
boven, zodat x, als x in A zit, “tussen”
onder en boven zit
• Invariant: als er een i is met A[i] == x, dan
onder  i  boven
Tijd van binary search
• Iedere keer wordt het stuk waar je kijkt
ongeveer half zo lang
• Je kan log n (grondtal 2) keer doormidden
delen en dan heb je een stuk van lengte 1
• Dus O(log n) stappen
• Nette wiskundige analyse komt later
Pseudocode
• {Input: Gesorteerde array A[1 … n] , element x}
• {Output: index i met A[i] == x, and 0 als zo’n i niet
bestaat}
• onder = 1; boven = n;
• while (onder < boven) do
– mid =  (onder+boven)/2 
– if (A[mid] < x)
then onder = mid+1
else boven = mid
• if (A[onder] == x)
then return onder
else return 0 (zit er niet in)
Sorteren
• Gegeven: een rij van n getallen (a1, … , an)
• Gevraagd: een permutatie van de input (a’1, … , a’n) zodat
a’1 a’2  …  a’n
• Kan natuurlijk ook met andersoortige geordende objecten
(bijv. verzameling woorden die gealfabetiseerd moeten
worden).
Datastructuren
Insertion sort
• Sorteeralgoritme, met volgende idee:
– Voeg steeds één element toe op de goede plek
– We hebben een steeds groter goedgesorteerd deel
– Array A loopt van 1 t/m lengte(A)
INSERTION-SORT(A)
for j = 2 to lengte(A) do
key = A[j]
{voeg A[j] op de goede plek in}
i = j – 1;
while i > 0 and A[i] > key do
A[i+1] = A[i] {schuif eentje op}
i = i – 1;
A[i+1] = key
Datastructuren
Idee van Insertion Sort
INSERTION-SORT(A)
for j = 2 to lengte(A) do
key = A[j]
{voeg A[j] op de goede plek in}
i = j – 1;
while i > 0 and A[i] > key do
A[i+1] = A[i]
{schuif eentje op}
i = i – 1;
A[i+1] = key
•
•
•
Eerst is rijtje met alleen eerste
element goed gesorteerd: (A[1])
Loop doet: van 2 tot eind: stop A[j]
op de goede plek
Zo: bewaar A[j]; van j naar voren,
schuif steeds element eentje naar
achter tot we op de plek komen
waar A[i] moet staan
Datastructuren
Correctheid van Insertion Sort 1
INSERTION-SORT(A)
for j = 2 to lengte(A) do
(*)
key = A[j]
{voeg A[j] op de goede plek in}
i = j – 1;
while i > 0 and A[i] > key do
A[i+1] = A[i]
{schuif eentje op}
i = i – 1;
A[i+1] = key
•
•
•
Bewijs correctheid met loopinvariant:
Als we bij (*) zijn, dan heeft het
deelarray
A[1 … j – 1] dezelfde elementen
als oorspronkelijk in
A[1 … j – 1], maar in gesorteerde
volgorde
Stap 1 van het bewijs: de
loopinvariant geldt initieel
Datastructuren
Correctheid van Insertion Sort 2
INSERTION-SORT(A)
for j = 2 to lengte(A) do
(*)
key = A[j]
{voeg A[j] op de goede plek in}
i = j – 1;
while i > 0 and A[i] > key do
A[i+1] = A[i]
{schuif eentje op}
i = i – 1;
A[i+1] = key
(**)
•
Als we bij (*) zijn, dan heeft het
deelarray
A[1 … j – 1] dezelfde elementen
als oorspronkelijk in
A[1 … j – 1], maar in gesorteerde
volgorde
• Stap 2 van het bewijs: als de
loopinvariant geldt voordat we
de loop ingaan, dan geldt als we
bij (**) zijn:
– Het deelarray A[1 … j] bevat
dezelfde elementen als
oorspronkelijk in A[1 … j],
maar in gesorteerde volgorde
• Dus blijft invariant geldig
Datastructuren
Correctheid van Insertion Sort 3
INSERTION-SORT(A)
for j = 2 to lengte(A) do
(*)
key = A[j]
{voeg A[j] op de goede plek in}
i = j – 1;
while i > 0 and A[i] > key do
A[i+1] = A[i]
{schuif eentje op}
i = i – 1;
A[i+1] = key
(**)
•
Stap 3 van het bewijs: nu geldt
invariant voor j = lengte(A)+1,
dwz.:
•
•
Datastructuren
Het deelarray A[1 …
lengte(A)] bevat dezelfde
elementen als
oorspronkelijk in
A[1 … lengte(A)], maar in
gesorteerde volgorde
Algoritme doet wat we
willen
Tijdsanalyse
• Tijd van een algoritme: hangt meestal af van:
– De implementatie (code, taal, compiler, …)
– De machine
– En de input
• Maar meestal kunnen we toch die tijd goed analyseren
– Langzaam algoritme blijft langzaam op langzame computer
– …
• Conventies:
– O-notatie om wat implementatieaspecten te onderdrukken
– Tellen van alle basisoperaties als 1 stap
– Kijken naar slechtste (of: gemiddelde en heel soms beste) geval
Datastructuren
Basisoperaties
• Tijd onafhankelijk van compiler en machine (afhankelijk van
programma en van input):
• Tel de basisoperaties:
– rekenkundige operatie op integer, Boolean, character;
– assignatie aan getal, boolean, character,reference (pointer)
– doorlopen van een reference naar de inhoud ervan
– indexberekening van een array
– het pakken van een veld uit een record/structure
– parameter overdracht bij aanroep function, methode
• Zo tel je: hoeveel operaties doet algoritme op een bepaalde input
• Formeel: Random Access Machine model
Datastructuren
Optimisten en pessimisten
• Analyse:
– Slechtste geval?
– Beste geval?
– Gemiddelde geval?
Is algoritmische analyse iets voor
pessimisten?
• Meest gebruikelijke analyse:
– Stel we hebben een input van lengte n
– Wat is het maximum aantal operaties dat ons algoritme
kan doen?
• Worst case – slechtste geval
Datastructuren
Optimisten en gewone mensen
• Wat is het gemiddelde aantal operaties dat ons algoritme
kan doen over alle mogelijke inputs van lengte n
– Average case – gemiddelde geval
– Probleempjes: vaak moeilijk om uit te rekenen; wat is
eigenlijk de kansverdeling over de inputs (komen alle
inputs even vaak voor als mogelijke input???)?
• Wat is het minimum aantal operaties dat ons algoritme kan
doen op inputs van lengte n?
• Best case – beste geval (meestal niet zo interessant, behalve
voor aartsoptimisten)
Twee technieken voor
tijdsanalyse
• Tel van elke basisoperatie hoe vaak deze wordt uitgevoerd
• Analyseer de loopstructuur van je algoritme van binnen
naar buiten
• Geavanceerdere technieken bestaan ook
– Analyse van recursieve algoritmen met recurrente
betrekkingen
– …
Datastructuren
Analyse van ZOEK-ELEMENT
ZOEK-ELEMENT(x,A)
{Input: Een element x en een array A
(A loopt van 1 tot lengte(A))}
{Output: Een index i zodat A[i] = x
of 0 als geen element in A gelijk
is aan x}
i = 1;
while i  lengte(A) do
if (x == A[i]) then return i
else i = i + 1;
endif
enddo;
return 0
• Elke slag van de while-loop
doet 6 basisoperaties (of zo), en
dit doen we voor elk van de
elementen van de array hooguit
1 keer.
• Dus op een array met n
elementen maximaal 6n+2
stappen
• Notatie: O(n) (leg ik later uit)
• Best case: O(1); average case:
O(n)
Datastructuren
Tijdsanalyse van
INSERTION-SORT 1
INSERTION-SORT(A)
for j = 2 to lengte(A) do
(*)
key = A[j]
{voeg A[j] op de goede plek in}
i = j – 1;
while i > 0 and A[i] > key do
A[i+1] = A[i]
{schuif eentje op}
i = i – 1;
A[i+1] = key
(**)
• Eerst dit:
• Hoeveel stappen kost één slag van
de loop voor een bepaalde waarde
van j ?
– Weer een loop.
– Elke doorgang door de loop kost
iets van 8 elementaire stappen
– Deze loop gaan we hooguit j keer
rond
– Nog eens 6 operaties buiten de
loop
– Dus 8 j + 6 operaties voor deze
slag
Datastructuren
Tijdsanalyse van
INSERTION-SORT 2
INSERTION-SORT(A)
for j = 2 to lengte(A) do
(*)
key = A[j]
{voeg A[j] op de goede plek in}
i = j – 1;
while i > 0 and A[i] > key do
A[i+1] = A[i]
{schuif eentje op}
i = i – 1;
n
A[i+1] = key
j 2
(**)
• Hoeveel stappen kost één slag
van de loop voor een bepaalde
waarde van j ?
– 8 j + 6 of minder
• We doen dit voor j=2, 3, … , tot
lengte(A)=n
• Totaal: constante keer n2
• Schrijven we als O(n2)
2
2


8
j

6

4
n

...

O
(
n
)

Datastructuren
Tenslotte
•
Volgende keer:
– O-notatie: hoe zit dat nou precies?
– Zoeken: binary search
– Sorteren
Datastructuren