INF2810: Funksjonell Programmering. Trær og mengder

Transkript

1 INF2810: Funksjonell Programmering Trær og mengder Stephan Oepen Universitetet i Oslo 16. februar 2016

2 Tema 2 Forrige uke Høyereordens prosedyrer lambda, let og lokale variabler Dataabstraksjon I dag Lister av lister Rekursjon på trær Eksempel: Mengder Neste uke Eksempel: Huffmankoding

3 Repetisjon: Lokale variabler, let og lambda 3 Regne ut prosentandel av summen ( normalisering )? (percentages '( )) ( ) (define (percentages items) (map (lambda (x) (/ x (/ (reduce + 0 items) 100))) items)) (define (percentages items) (let ((sumcent (/ (reduce + 0 items) 100))) (map (lambda (x) (/ x sumcent)) items))) (define (percentages items) ((lambda (sumcent) (map (lambda (x) (/ x sumcent)) items)) (/ (reduce + 0 items) 100)))

4 Repetisjon: Dataabstraksjon og komplekse data 4 Ofte behov for å binde sammen en gruppe sammenhengende data. Komplekse datatyper grupperer informasjon som konseptuelt hører sammen (compound data), f.eks. rasjonale tall: 1/3. Dataabstraksjon skjuler en datatypes interne representasjon. Familie av prosedyrer som grensesnitt: konstruktor, selektorer, predikat. (define (make-rat n d) (cons n d)) (define (numer r) (car r)) ;; (define numer (define (denom r) (cdr r)) ;; (lambda (r) (car r))) (define (rat? r) (pair? r)) ;; (define numer car) Nok for å definere prosedyrer som konseptuelt regner på rasjonale tall. Grensesnittet danner dermed en abstraksjonsbarriere iht. kontrakten.

5 Repetisjon: Par som prosedyre! 5 (define (cons x y) (lambda (message) (cond ((= message 0) x) ((= message 1) y)))) (define (car proc) (proc 0)) (define (cdr proc) (proc 1))? (cons 1 2) #<procedure>? (cdr (cons 1 2)) 2? (car (cons 1 (cons 2 3))) 1 Selv datastrukturer kan implementeres som prosedyrer! Par som prosedyre: Returnerer enten car- eller cdr-verdien, avhengig av hvilken kode den får (0/1). Eksempel på såkalt message passing. car og cdr kaller par-prosedyren (laget med cons) med beskjed om hvilken verdi som ønskes.

6 Lag på lag: Prosedyre- og dataabstraksjon 6

7 Trær 7 Et tre er en type graf, en mengde noder forbundet med kanter. Interne noder har barn / døtre: nye subtrær. Den øverste noden kalles rot. Løvnoder har ikke barn (såkalt terminalnoder). Kantene kan ikke være sykliske. Binærtrær: nodene har maks to døtre, venstre/høyre. I Scheme kan vi representere trær som lister av lister.

8 Lister som trær 8 Flate lister: sekvenser. Lister av lister: kan sees som trær. Hvert element i en liste er en gren. Elementer som selv er lister er subtrær. Løvnodene i treet er de atomære elementene som ikke er lister. PS: Har bare verdier på løvnodene her, men etterhvert skal vi lage en mer generell implementasjon av trær.

9 Rekursjon på trær (eksempel 1:3) 9 For eksempel: telle løvnoder (parallelt til length på sekvenser). Må passe på at rekursjonen går ned i hver (element)liste. Må tenke på tre forskjellige situasjoner. Argumentet kan være: den tomme lista en cons-celle (et tre) noe annet (løvnode) (define (count-leaves tree) (cond ((null? tree) 0) ((pair? tree) (+ (count-leaves (car tree)) (count-leaves (cdr tree)))) (else 1)))? (count-leaves '((1 2) 3 4)) 4

10 Rekursjon på trær (eksempel 2:3) 10 (define (fringe tree) (cond ((null? tree) '()) ((pair? tree) (append (fringe (car tree)) (fringe (cdr tree)))) (else (list tree))))? (fringe '((1 2) ((3) 4))) ( ) ;; append kombinerer to lister; ;; sammenlikning med cons:? (append '(1 2) '(3)) (1 2 3)? (cons '(1 2) '(3)) ((1 2) 3) Et annet eksempel: samle opp alle løvnodene i en flat liste. Typisk eksempel på rekursjon på lister av lister: Vi ønsker å gjøre noe for hvert atomære element (løvnodene). Må passe på at rekursjonen går ned i hver liste. To basistilfeller: tomt tre eller løvnode.

11 Rekursjon på trær (eksempel 3:3) 11 map er definert for lister: tree-map kan defineres for lister av lister: (define (tree-map proc tree) (cond ((null? tree) '()) ((pair? tree) (cons (tree-map proc (car tree)) (tree-map proc (cdr tree)))) (else (proc tree))))? (tree-map square '((1 2) 3 4)) ((1 4) 9 16) Alternativt kan map brukes, i kombinasjon med rekursjon: (define (tree-map proc tree) (map (lambda (subtree) (if (pair? subtree) (tree-map proc subtree) (proc subtree))) tree)) Hvorfor trengs det bare én rekursiv oppkalling i denne varianten?

12 Trerekursjon 12 count-leaves, fringe, osv. vil gi en trerekursiv prosess. Fikk dårlig rykte da vi så på fib tidligere: eksponentiell vekst og masse redundante beregninger. Prosesstreet gjenspeilet trinnene i en naiv algoritme. Her gjenspeiler det bare strukturen til inputdata. Kompleksiteten lineær i antall noder i input. Ingen redundans.

13 Veien videre 13 Så langt: Kan representere trær, men bruker bare pair?, null?, cons, car og cdr direkte. Ingen abstraksjon! Vi skal definere abstrakte datatyper for trær der ikke bare løvnodene, men også de interne nodene kan ha verdier. Skal også jobbe med eksempler der rekursjonen velger å kun følge én gren (i stedet for å gå ned i alle subtrær). Som praktiske eksempler skal vi se på hvordan både mengder og komprimeringskoder kan implementeres effektivt som trær.

14 Først 14 Skal se 3 implementasjoner av en abstrakt datatype for mengder (hvorav den tredje er basert på trær).

15 Mengder (som matematisk konsept) 15 En uordnet samling elementer. Uordnet (usortert): {1, 2, 3} = {2, 3, 1} Distinkte (unike) elementer: {1, 2, 3, 3, 1} = {1, 2, 3} Vi skal se på ulike måter å representere mengder. Som dataabstraksjon er eneste krav at vi kan definere følgende: element-of-set? - spør om et element er medlem av en mengde. adjoin-set - returnerer en mengde med et gitt element lagt til som medlem. intersection-set - tar to mengder og returnerer en mengde der kun elementer som er medlem av dem begge er med (snitt). union-set - tar to mengder, returnerer en mengde med alle elementer fra begge.

16 Representasjon av mengder #1: Uordnet liste 16 (define (element-of-set? x set) (cond ((null? set) #f) ((= x (car set)) #t) (else (element-of-set? x (cdr set))))) (define (adjoin-set x set) (if (element-of-set? x set) set (cons x set))) (define (intersection-set set1 set2) (cond ((or (null? set1) (null? set2)) '()) ((element-of-set? (car set1) set2) (cons (car set1) (intersection-set (cdr set1) set2))) (else (intersection-set (cdr set1) set2)))) Mengder som uordnede lister. {5, 1, 3, 9, 7, 11} = '( ) Ingen elementer forekommer mer enn én gang. {} = '() element-of-set? er sentral.

17 Kompleksitet 17 Hva er kompleksiteten til element-of-set?? Predikatet søker sekvensielt gjennom lista helt til vi finner elementet vi ser etter ( #t), eller det ikke er flere elementer igjen ( #f). I værste fall O(n) gitt en mengde med n elementer. Det samme gjelder dermed for adjoin-set. intersection-set involverer sjekk av medlemskap for hvert element i en mengde mot en annen: O(n 2 ) for to lister med n elementer. Det samme vil gjelde union-set.

18 Representasjon av mengder #2: Ordnet liste 18 En enkel måte å gjøre operasjonene mer effektive på er å endre representasjonen til å være ordnet. F.eks: numerisk eller leksikografisk rekkefølge. gi hvert element et numerisk id og sorter på dette. Trenger uansett en måte å sammenlikne objekter på. For strenger kunne vi brukt string>?, string<? og string=?. (PS: Det finnes også en prosedyre symbol->string.) Fortsetter vi å anta at elementene er tall kan vi bruke <, > og =. {5, 1, 3, 9, 7, 11} = ( )

19 Sjekk av medlemskap mot ordnet liste 19 Ny versjon av element-of-set? (Antar at mengden er gitt som en sortert liste av tall.) (define (element-of-set? x set) (cond ((null? set) #f) ((= x (car set)) #t) ((< x (car set)) #f) (else (element-of-set? x (cdr set))))) Trenger ikke lenger nødvendigvis sjekke hvert element: kan avbryte hvis vi finner et større element. Fortsatt teoretisk O(n) vekst (f.eks i tilfellet elementet er det siste). Men i praksis kan vi regne med at antall trinn i snitt vil være n/2.

20 Snitt for ordnede lister (1:2) 20 (define (intersection-set set1 set2) (if (or (null? set1) (null? set2)) '() (let ((x1 (car set1)) (x2 (car set2))) (cond ((= x1 x2) (cons x1 (intersection-set (cdr set1) (cdr set2)))) ((< x1 x2) (intersection-set (cdr set1) set2)) ((< x2 x1) (intersection-set set1 (cdr set2))))))) Enda mer å spare på implementasjonen av snitt: Sammenlikner første element i hver liste: Hvis de er like inkluderer vi det, og ser videre på cdr av listene. Hvis det ene er mindre enn det andre vet vi at det ikke kan være medlem og vi ser på cdr av lista med det minste elementet.

21 Snitt for ordnede lister (2:2) 21 (define (intersection-set set1 set2) (if (or (null? set1) (null? set2)) '() (let ((x1 (car set1)) (x2 (car set2))) (cond ((= x1 x2) (cons x1 (intersection-set (cdr set1) (cdr set2)))) ((< x1 x2) (intersection-set (cdr set1) set2)) ((< x2 x1) (intersection-set set1 (cdr set2))))))) I hvert trinn reduseres problemet til snittet av mindre mengder. Utnytter den ordnede representasjonen direkte, kaller ikke element-of-set?. Antallet trinn er i værste fall proporsjonalt med summen av lengdene på listene (i stedet for produktet) O(n) vekst i stedet for O(n 2 ).

22 Representasjon av mengder #3: Binærtrær 22 Enda mer effektivt: mengde som binærtre med ordnede noder. Hver node lagrer et element en venstregren med mindre elementer en høyregren med større elementer Ved søk etter et gitt element x: Hvis x er mindre enn nodeverdien, søk til venstre. Hvis x er større, søk til høyre. Kan halvere søkerommet i hvert trinn: Logaritmisk vekst: O(log n).

23 Abstraksjonsbarriere for binærtrær 23 Vi representerer mengder som trær, og trær som lister. Har allerede abstraksjonsbarriere for mengder, men mangler for trær. Konstruktor og selektorer: (define (make-tree entry left right) (list entry left right)) (define (entry tree) (car tree)) (define (left-branch tree) (cadr tree)) (define (right-branch tree) (caddr tree))

24 Mengdeoperasjoner for binærtrær 24 (define (element-of-set? x set) ;; log(n) vekst (cond ((null? set) #f) ((= x (entry set)) #t) ((< x (entry set)) (element-of-set? x (left-branch set))) ((> x (entry set)) (element-of-set? x (right-branch set))))) (define (adjoin-set x set) ;; samme strategi (cond ((null? set) (make-tree x '() '())) ((= x (entry set)) set) ((< x (entry set)) (make-tree (entry set) (adjoin-set x (left-branch set)) (right-branch set))) ((> x (entry set)) (make-tree (entry set) (left-branch set) (adjoin-set x (right-branch set))))))

25 Flere trær for samme mengde 25 Kan finnes flere mulige trær for én og samme mengde. Eksempel på noen mulige trær for {5, 1, 3, 9, 7, 11}:

26 Balanserte trær 26 adjoin-set bruker samme strategi som element-of-set? og får O(log n) vekst. Forutsetter at treet er relativt balansert. Eksempel på tre laget med adjoin-set anvendt i sekvens på 1 til 7. Ingen besparelser i forhold til en ordnet liste. Med tilfeldig distribuerte elementer kan vi forvente at trærne i snitt er balanserte. Men vi har ingen garanti. Kan løses ved å ha en prosedyre som sørger for å balansere treet jevnlig (eller bruke mer sofistikerte trestrukturer).

27 Abstraksjonsbarrieren lekker litt 27 (define (adjoin-set x set) (cond ((null? set) (make-tree x '() '())) ((= x (entry set)) set) ((< x (entry set)) (make-tree (entry set) (adjoin-set x (left-branch set)) (right-branch set))) ((> x (entry set)) (make-tree (entry set) (left-branch set) (adjoin-set x (right-branch set)))))) Koden slik den er gitt i SICP har noen lekkasjer i abstraksjonsbarrieren: Skjuler ikke alle designvalgene våre for binærtrær. Burde hatt et predikat empty-tree? Og kanskje en konstant empty-tree. Eller (make-leaf x) i stedet for (make-tree x '() '()).

28 Og nå En liten digresjon.

29 Aritet 29 Ariteten til en prosedyre refererer til antall argumenter den tar. Vi har allerede sett prosedyrer som kan ta null argumenter (niladic function), ett argument (unær / monadic), to eller flere argumenter (polyadic): to (binær / dyadic), tre (ternær / triadic) osv et variabelt antall argumenter (n-ær / variadic).? (+) 0? (+ 1 2) 3? ( ) 6? ( ) 61 Vi kan også definere våre egne n-ære prosedyrer.

30 Variadiske prosedyrer 30 (define (sum. args) (define (recurse list) (if (null? list) 0 (+ (car list) (recurse (cdr list))))) (recurse args))? (sum 1 2 3) 6 Prikk-notasjon: parameterene etter prikken er valgfrie og samles i listen args. Hvorfor trengs egentlig den indre rekursive prosedyren? (define (sum. args) (if (null? args) 0 (+ (car args) (sum (cdr args))))) Hva vil skje her? Hva er verdien til parameteret args i 1. og 2. oppkalling?? (sum 1 2 3)???

31 Mer om prikk-notasjon, for de spesielt interesserte? (cons 1 (cons 2 3)) (1 2. 3)? (cons 1 (cons 2 (cons 3 '()))) (1 2 3)? '(1. (2. 3)) (1 2. 3)? '(1. (2. (3. ()))) (1 2 3) '(1 2) = cons-kjeden '(1. (2. ())) Er cdr et par eller () sløyfer Scheme punktum og parentes:. (.? (+ 1 2) 3? (+. (1. (2. ()))) 3? (define (square x) (* x x))? (define. ((square. (x. ())). ((*. (x. (x. ()))))))? (define (map fn list1. lists)...) Scheme kan også lese slik dot-notasjon. Husk at kode = lister. Utnytter denne notasjonen til å skrive prosedyrer som tar et variabelt antall argumenter. 31