Träd Träd Träd Träd, ex på användning: släktträd

Träd
Ett träd består av ett antal noder och bågar.
Det tomma trädet har inga noder eller bågar.
• Om trädet inte är tomt så finns det en speciell nod,
roten.
• Varje nod c i trädet, utom roten, är med en båge
förbunden med en annan nod p. p är förälder till c.
cärbarn till p.
• Det finns en entydig väg från roten till varje nod.
Ex
Träd
Man kan också definiera träd rekursivt:
Ett träd är antingen tomt eller så består det av en speciell
nod (roten) och noll eller flera (icke-tomma) underträd
T 1 ,T 2 , ... T k .
Roten i vart och ett av underträden är förbundna med
roten i trädet.
T 1
T 2
T 3
AD: Träd 1
AD: Träd 2
Träd
Träd, ex på användning: släktträd
Noder som har samma förälder kallas ibland syskon.
Noder som saknar barn kallas löv, övriga är förgreningsnoder
Karl XIV Johan
1763-1844
Oskar I
1799-1876
rot
löv
Karl XV
1826-1872
Gustaf
1827-1852
Oskar II
1829-1907
Eugenie
1830-1889
August
1831-1873
löv
löv
AD: Träd 3
AD: Träd 4

Träd, ex på användning: spelträd
Beskriver vilka
spelställningar
som kan uppstå till
följdavdrag,
utgående från en viss
startställning.
x o
o x
x o
x o x o
o x
o x
x o
x o
Kan användas för
att hitta ”vinnande
strategi” i spelet.
Träd, ex på användning: representation
av aritmetiska uttryck
+
1 *
2 3
1
+
2
*
3
o
x
x
o
x
o
x
o
x
o
o
x
x
o
o
x
x
o
o
x
1+2*3
(1 + 2) * 3
x
o
x
o
x
o
x
o
x
o
AD: Träd 5
AD: Träd 6
Träd, ex på användning: binära sökträd
Träd: ex på representation
Hans
Mona
Svea
class Node {
Node firstChild;
Node nextSibling;
object element; //nodens
//innehåll
}
Anna
Karl
Nora
Tora
Används för att lagra element som innehåller ”söknyckel” för vilken
jämförelseoperationer är definierade. Här: sträng.
Nycklarna i vänster underträd är mindre än rotens nyckel som
i sin tur är mindre än nycklarna i höger underträd.
Kommer vi att behandla utförligt senare.
Fördel: Enkelt och snabbt att leta upp, sätta in och ta bort element.
AD: Träd 7
class Tree {
private Node root;
...
}
Varje nod innehåller två attribut, firstChild som refererar till det
”äldsta” barnet och nextSibling som refererar till nästa syskon i
syskonskaran. I roten är alltid nextSibling null. I alla löv är
firstChild null. Träd-klassen innehåller ett attribut som refererar till
rot-noden.
AD: Träd 8

Binära träd
Begreppet höjd av nod/träd
Def: Ett träd är binärt om varje nod har högst två barn.
Def: Ett träd är strikt binärt om varje nod har antingen
noll eller två barn.
AD: Träd 9
Def: Höjden h(x) hos en nod x är antalet bågar på den längsta
vägen ner till ett löv i det underträd i vilket x är rot.
z
x
y
u
h(x) = 3
h(y) = 1
h(z) = 2
h(u) = 0
Def: Höjden hos ett träd T, h(T) = h(roten).
Trädets höjd är viktig i värstafallsanalys av t ex operationer
på binära sökträd.
OBS: Många böcker använder en definition av höjden som
avviker med 1 från vår: de räknar antalet bågar +1 på längsta
vägen ned till löv.
AD: Träd 10
Begreppet djup för en nod
Def: Djupet d(x) hos en nod x är antalet bågar på (den
entydiga) vägen upp från x till roten.
x
z
v
y
u
d(x) = 0
d(y) = 1
d(z) = 1
d(u) = 2
d(v) = 3
Anm: Ibland förekommer också begreppet nivå för en nod i
ett träd. Roten har nivå 1. En godtycklig annan nod har nivå
ett mer än sin förälder.
Enkelt samband: nivå(x) = d(x) + 1
AD: Träd 11
Samband mellan antal noder och höjd
hos binära träd
För alla binära träd T med n noder gäller att
h(T) ÿ n–1 (1)
och
h(T) 2
log (n+1) –1 (2)
(1) är enkelt att inse. Trädet får största möjliga höjd om man
placerar en nod på varje nivå. Höjden blir då n–1.
Ex för n= 3:
AD: Träd 12

Samband mellan antal noder och höjd
hos binära träd
Minimal höjd för ett binärt träd
(2):
På djupet noll finns en nod (roten).
På djupet ett högst 2 noder, på djupet 2 högst 4 noder etc.
Allmänt finns det på djupet i högst 2 i noder.
Det största djupet i ett träd med höjd h är h.
==> n ÿ 1+2+4+...+2 i + ... + 2 h =2 h+1 –1.
Vilket ger att h 2
log (n+1) – 1
AD: Träd 13
Ett binärt träd med n noder har minimal höjd om
n>2 h –1.
Förklaring: Så många noder kan inte få plats i ett träd
medlägrehöjdänh.(Ettträdmedhöjdenh–1
rymmerjuhögst2 h – 1noder (se föregående bild).
För binära träd med minimal höjd gäller därmed
2
log(n+1)–1ÿ h< 2 log(n+1)
vilket ger att h log n.
AD: Träd 14
Binära träd med minimal höjd
Lätt att se om trädet har minimal höjd. Kan man flytta några
noder så att höjden blir mindre så har trädet inte minimal
höjd.
Minimal höjd
Ej minimal höjd. Man kan
flytta en nod och minska höjden
AD: Träd 15
Binära träd, representation
Det implementationsförslag som gavs för generella träd med firstChild- och
nextSibling-referenserinodernapassarintesåbraförbinäraträd.Idessavill
man tillåta att en nod saknar vänster barn men har ett höger barn. I stället kan vi
göra så här:
class BinaryNode {
BinaryNode left; // refererar till vänster barn
BinaryNode right; // refererar till höger barn
Object element;
// nodens innehåll
... // här infogas operationer
element
}
class BinaryTree {
private BinaryNode root;
...// operationer på träd
}
left right
AD: Träd 16

Binära träd, representation
I det implementationsförslag som finns på förra bilden utnyttjas inte stödet
för att skriva generiska klasser som finns i Java 5.0. Om man gör det blir det
istället så här :
class BinaryNode {
BinaryNode left; // refererar till vänster barn
BinaryNode right; // refererar till höger barn
E element;
// nodens innehåll
... // här infogas operationer
}
class BinaryTree {
private BinaryNode root;
...// operationer på träd
}
element
left right
AD: Träd 17
Binära träd och rekursion
Trädens rekursiva definition gör att många operationer på
träd enklast implementeras rekursivt.
Ex: Skapa en kopia till ett binärt träd.
Rekursiv metod:
Skapa en kopia rootCopy av roten.
rootCopy.left = kopia av vänster underträd
rootCopy.right = kopia av höger underträd
Basfall: ett tomt träd. Kopian är då null.
AD: Träd 18
Kopiera binärt träd, rekursiv utformning
Kopiera binärt träd, rekursiv utformning
/** Skapa en kopia av detta binära träd */
public BinaryTree duplicate() {
BinaryTree copy = new BinaryTree();
if (root!=null) {
copy.root = root.duplicate();
}
return copy;
}
Denna metod i klassen
BinaryTree
BinaryNode duplicate() {
BinaryNode node = new BinaryNode(element);
if (left!=null){
node.left = left.duplicate();
}
if (right!=null){
node.right = right.duplicate();
}
return node;
}
Denna metod i klassen
BinaryNode
AD: Träd 19
AD: Träd 20

Kopiera binärt träd, alternativ rekursiv
utformning
public BinaryTree duplicate() {
BinaryTree copy = new BinaryTree();
copy.root = duplicate(root);
return copy;
}
Båda dessa placeras i
klassen BinaryTree. Den
publika metoden är inte
rekursiv, men är "driver"
för den privata rekursiva
metoden, där det huvudsakliga
arbetet utförs.
private BinaryNode duplicate(BinaryNode n) {
if (n==null) {
return null;
} else {
BinaryNode newNode = new BinaryNode(n.element);
newNode.left = duplicate(n.left);
newNode.right = duplicate(n.right);
return newNode;
}
}
AD: Träd 21
Traversering av binära träd
Att traversera ett träd betyder att man ”besöker” dess noder
en efter en i någon ordning. I samband med besöket utför
man någonting, beroende på vilket problem man håller på att
lösa. Det finns flera sätt att traversera träd, bl a:
• Nivå för nivå med början på rotens nivå. På varje nivå
besöks noderna i ordning från vänster till höger. Brukar
kallas level-by-level, top-down.
• Nivå för nivå med början på den nivå som ligger längst bort
från roten. På varje nivå besöks noderna i ordning från
vänster till höger. Brukar kallas level-by-level, bottom-up
AD: Träd 22
Rekursivt definierade traverseringar
Det finns också tre rekursivt definierade sätt att besöka alla
noder i ett binärt träd:
Rekursivt definierade traverseringar, ex
M
Preorder:
Inorder:
Postorder:
Först roten
Sedan vänster underträd i preorder
Sedan höger underträd i preorder
Först vänster underträd i inorder
Sedan roten
Sedan höger underträd i inorder
Först vänster underträd i postorder
Sedan höger underträd i postorder
Sedan roten
AD: Träd 23
H
S
A K N T
Preorder: M,H,A,K,S,N,T
Inorder: A, H, K, M, N, S, T
Postorder: A, K, H, N, T, S, M
AD: Träd 24

Implementation av rekursiva
traverseringar
Implementation av rekursiva
traverseringar
Skiss av hur genomgång av ett binärt träd i preorder kan
implementeras i Java. (Vi förutsätter n!=null vid anrop):
public void preOrder(BinaryNode n) {
// här infogas satser som utför det som skall
// göras då noden n besöks
if (n.left!=null) {
preOrder(n.left); // (*) se nästa bild
}
if (n.right!=null) {
preOrder(n.right); // (**) se nästa bild
}
}
AD: Träd 25
• Vid inorder-genomgång placeras satserna som
”behandlar” noden i stället efter den sats som
kommenterats med (*) ovan.
• Vid postorder-genomgång placeras de efter satsen som
kommenterats med (**).
Samtidigt byter man naturligtvis namn på metoden.
AD: Träd 26
Traversering av träd
Många algoritmer för träd kan tolkas som traversering i en
viss ordning:
• Evaluering av aritmetiskt uttryck. Underträdens värden
måste först evalueras. Alltså postorder.
• Skriva ut innehållet i ett binärt sökträd i växande ordning.
Blir inorder.
• Metoden duplicate är exempel på preordertraversering.
Först skapas kopia på noden där vi befinner oss, sedan på
dess underträd.
Ibland saknar ordningen betydelse. Skall vi t ex räkna antalet
noder kan vi besöka dem i vilken ordning som helst, bara alla
blir besökta (räknade) precis en gång.
AD: Träd 27
Traversering av träd
Problem med implementationen i Java på tidigare bild:
• Satser för att ”behandla” den nod som besöks måste
infogas i traverseringsmetoden och kan inte varieras av
den som anropar metoden. Den som implementerar en
ADT för binära träd kan inte förutse vad olika användare
kan tänkas önska att ”behandla” skall innebära.
• Det finns inget sätt att avbryta traverseringen innan alla
noder besöks. Det kan behövas om t ex ”behandla”
innebär att man söker efter nod med visst innehåll.
AD: Träd 28

Traversering/iteratorer
Traversering/iteratorer
För att komma tillrätta med dessa problem är det önskvärt att
ha s.k. externa iteratorer för träd. Vi vill alltså ha något som
motsvarar iteratorer för listor, d.v.s. en klass med operationer
för att ”hämta nästa element” och undersöka ”om det finns
fler element”.
För binära träd vill man helst ha flera olika implementationer
av ett sådant interface. En där ”nästa” betyder nästa element
vid en preordergenomgång, en där ”nästa” betyder nästa vid
en inordergenomgång etc.
I läroboken finns i avsnitt 18.4 beskrivet hur iteratorer på
binära träd kan implementeras (med hjälp av stack).
Kan läsas kursivt.
När vi senare går igenom sökträd kommer vi att titta på
vilket stöd för iteration det finns i Javas klasser (TreeSet
och TreeMap).
AD: Träd 29
AD: Träd 30
Nivå- för nivåtraversering
Kan implementeras med hjälp av en kö:
Skapa en tom kö;
Lägg in rotnoden i kön;
Så länge kön inte är tom
Tag ut och behandla första noden (actNode);
Om actNode.left!=null
Lägg in actNode.left i kön;
Om actNode.right!=null
Lägg in actNode.right i kön;
Kan generaliseras till andra trädtyper än binära. Man lägger
då in alla barnen (från vänster till höger) i kön.
AD: Träd 31
Ex. på användning av träd som abstrakt
modell: Filkomprimering
Representera n olika symboler med binära strängar av lika längd L.
Detkrävsdåatt2 L n. Alltså blir minsta möjliga L log n.
Ex:Påenfilförekommerendast8olikatecken:c,d,e,f,k,l,u,z.
L = 3 räcker alltså.
Tecken
Antal
Kod (t ex)
Antal bitar
c
32
000
96
d
42
001
126
e
120
010
360
f
24
011
72
k
7
100
21
42
101
126
37
110
111
Totalt antal bitar: 918. Jfr vanlig ASCII: 306 tecken * 8
bitar = 2448 bitar. Men det går att göra bättre.
z
2
111
6
AD: Träd 32
l
u

Filkomprimering
Det går att komprimera filen bättre om man tillåter olika
längd på kodorden.
Idé: Korta kodord för frekventa tecken och längre för
mindre frekventa.
Villkor: Kodningen måste vara sådan att mottagaren kan
avkoda mottagen sträng entydigt med kännedom
om hur de enskilda symbolerna översätts.
Ex: Treteckena,b,c.Kodas0,1respektive01
Mottagen kodad sträng: 001.
Betyder aab eller ac
Prefix-kodning:
Filkomprimering
Ingen symbol kodas med en sträng som
utgör prefix till en annan symbols kodsträng.
Prefix-kodning => Entydig avkodning möjlig.
Mål:
För en given mängd symboler S och en
sträng av symboler ur S, finn en kodning
som uppfyller prefixvillkoret och som
minimerar längden på den kodade strängen.
AD: Träd 33
AD: Träd 34
Filkomprimering, prefixkodning
Filkomprimering
Prefix-kodning kan illustreras av ett binärt träd, ex (koden
på bild 31):
0
1
0
0 1 0 1 0 1 0 1
c d e f k l u z
1
0 1
Vänstergren motsvarar nolla i kodordet, högergren etta.
De tecken som kodas motsvarar löv. Väg från roten till
ett visst löv är kodordet för symbolen i lövet.
AD: Träd 35
Antag att symbolen x finns w(x) gånger i strängen som skall
kodas.
Längden på kodordet för x är d(x), (d(x)= djupet för det löv
som motsvarar symbolen x i kodträdet).
Totala längden för den kodade strängen L =
summationen görs över alla löv x i kodträdet.
Vi söker den prefixkodning som minimerar L.
w(x)*d(x), där
AD: Träd 36

Huffmans algoritm för optimal
prefixkodning
Börja med en serie träd, vardera bestående av ett enda löv.
Till varje träd associeras en av symbolerna som skall kodas
och en vikt = symbolens frekvens:
z
2
k
7
f c u d l e
24 32 37 42 42 120
Välj de två träd som har minst vikt. Bygg ihop dem till ett
träd, genom att låta dem bli vänster- respektive högerbarn
till en ny nod. Till det nya trädet associeras en vikt =
summan av de sammanslagna delträdens vikter.
Huffmans algoritm för optimal
prefixkodning
z
2
9 f
24
k
7
c u d l e
32 37 42 42 120
Fortsätt på samma sätt att slå samman två träd med minsta
vikt:
c
32
z
2
33
9 f
24
k
7
u d l e
37 42 42 120
AD: Träd 37
AD: Träd 38
Huffmans algoritm för optimal
prefixkodning
u d
37 42
l
42
c
32
z
2
65
33
9 f
24
k
7
… Efter ytterligare fyra steg får man ….
e
120
e
120
Huffmans algoritm för optimal
prefixkodning
306
0 1
0
0
79
1
u d
37 42
186
l
42
1
0
107
0
c
32
0
z
2
1
65
1
33
0 1
9 f
1
24
k
7
Kodtabell:
c 32 1110 128
d 42 101 126
e 120 0 120
f 24 11111 120
k 7 111101 42
l 42 110 126
u 37 100 111
z 2 111100 12
Σ = 785
AD: Träd 39
AD: Träd 40

ADT lexikon (map, dictionary,
symboltabell)
ADT lexikon
Ofta behöver man i datorprogram kunna hantera en mängd
element för vilka åtminstone en jämförelseoperation för
likhet är definierad. Jämförelse baseras oftast på en
”nyckel” som ingår i elementet.
Ex. elementen består av namn och telefonnummer.
Nyckeln är namnet.
Elementen i samlingen betraktas ofta som bestående av två
delar nyckeln och tillhörande värde, där jämförelse görs
med avseende på nyckeln.
Åtminstone följande tre operationer skall vara möjliga att
utföra:
• Sökning. Givet en nyckel, sök tillhörande värde.
• Insättning. Dubbletter tillåts vanligen inte.
• Borttagning.
En abstrakt datatyp med dessa operationer brukar kallas
lexikon eller symboltabell.
AD: Träd 41
AD: Träd 42
Implementation av Lexikon
Effektiv implementation av lexikon
Implementationsförslag:
Lista (länkad implementation)
Om listan hålls sorterad efter växande nycklar blir
alla operationer O(n).
Om listan är osorterad blir insättning O(1) men de
övriga O(n).
Vektor
Om den hålls sorterad blir sökningen O(log n)
(binärsökning).
Men insättning och borttagning blir O(n), ty man
måste flytta element i vektorn.
AD: Träd 43
Genom att använda binärt sökträd, får vi en implementation
av Map/Lexikon som förenar de goda egenskaperna hos
vektorimplementationen (snabb sökning) med det som är bra
med listimplementationen (snabb insättning, borttagning när
man har sökt upp rätt position).
Ett binärt sökträd är ett binärt träd där elementen är par
(nyckel, värde) och där nycklar i vänster underträd alltid är
mindre än rotens nyckel som i sin tur är mindre än alla
nycklar i höger underträd. Observera att detta skall gälla för
alla underträd i trädet.
AD: Träd 44

Binära sökträd
Binära sökträd, exempel
Ett binärt sökträd är ett binärt träd som i varje nod lagrar ett
element innehållande en nyckel och ett värde. För varje
nod x i trädet gäller:
x
Elementen i noderna i exemplet nedan innehåller en sträng
på vilken jämförelsen baseras. Ett element e 1 anses vara
mindre än e 2 om strängen i e 1 kommer alfabetiskt före
strängen i e 2 .
Mona
Hans
Svea
T L
T R
elementen i T L < elementet i x < elementen i T R
AD: Träd 46
Anna
Karl
Nora
Tora
AD: Träd 45
Anna
Hans
Karl
Mona
Binära sökträd, sökning
Lyckad sökning:
Sök efter Nora.
Börja i roten.
Om likhet, stanna.
Vik av åt vänster om det sökta
är mindre annars åt höger.
Pilarna anger sökvägen.
Nora
Svea
Tora
Misslyckad sökning:
Sök efter Lena.
Pilarna anger sökvägen.
Slutar när ingen nod finns i
den riktning man skall vika
av.
Anna
Hans
Karl
Mona
Lägg märke till likheten med binärsökning i vektor!
Nora
Svea
Tora
AD: Träd 47
Binära sökträd, insättning
Den nya noden sätts in som löv. Rätt plats letas upp
som i sökningsoperationen. Man kan därför samtidigt
kontrollera att nyckeln inte redan finns i trädet.
Insättning misslyckad sökning.
Ex: Sätt in Lena:
Anna
Hans
Karl
Mona
Lena
Nora
Svea
Tora
AD: Träd 48

Binära sökträd, borttagning
Leta först upp nyckeln som skall bort samt förälder (sökning).
Trädet skall efter borttagningen fortfarande vara ett binärt
sökträd!
Enklaste fallet: Den nod som skall bort är ett löv. Ex ta bort
nyckeln 1 ur trädet:
4
8
11
4
8
11
Binära sökträd, borttagning
Näst enklaste fallet: Den nod x som skall tas bort har bara ett
barn. T ex bara vänster barn. Ex: ta bort nyckeln 2:
förälder
4
8
11
förälder
x 2 6 9 13
1 6 9 13
4
8
11
1
2
5
6
7
9
13
2 6 9
Regel: Låt den ref i föräldern som refererar till noden som skall
bort bli null. Spec.fall: förälder saknas. => roten är ett löv =>
5
7
13
Sätt roten = null. AD: Träd 49
AD: Träd 50
1
5
7
Regel: Låt den ref i förälder som refererar till x i stället
referera till barnet till x.
Specialfall: förälder==null => x==roten. Sätt roten =
barnet till x.
5
7
Binära sökträd, borttagning
Binära sökträd, borttagning
Svåraste fallet: Noden som skall tas bort har två barn. Ex: ta
bort 8 ur trädet:
x
x
1
2
4
5
6
7
8
9
11
13
2
10 1 5 7 10
4
6
8
Steg 1: Leta upp minsta noden m i
x:s högra underträd. Forts …
9
11
13
m
1
2
x
4
6
5 7
9
9
11
10
13
Steg 2: Flytta innehållet
i m till x.
m
1
2
x
4
6
5 7
9
10
11
Steg 3: Tag bort m (som
har högst ett barn)
13
AD: Träd 51
AD: Träd 52

Binära sökträd
Trädets form beror på insättningsordningen.
Ex: Sätt in 1, 2, .., 7 Insättningsordningen
( i den ordningen) 4, 2, 1, 6, 5, 3, 7 ger:
1
2
3
4
5
6
7
4
2 6
1 3 5 7
Ordning:
2, 5, 1, 6, 7, 3, 4
AD: Träd 53
1
2
3
5
4
6
7
Analys av operationer på BST, värstafall
Lyckad sökning
• Kostnaden är proportionell mot antal noder på vägen
ner till sökt nod x, dvs. d(x)+1.
• I värsta fall söker vi det löv som ligger längst bort från
roten ==> i värsta fall = h(T)+1.
• I ett träd med n noder kan höjden maximalt bli n–1.
==> i värsta fall kostar sökning O(n).
• Minsta värde på höjden är log n. Värstafallstiden för
sökning i träd med minimal höjd är alltså O(log n)
Misslyckad sökning
• Antalet noder på den gren vi söker kan maximalt vara
n. Därför blir värstafallet O(n)
AD: Träd 54
Analys av operationer på BST, värstafall
Insättning
• Vi söker oss ner på en gren i trädet och sätter in det nya elementet som
ett löv. Det blir samma kostnad som för misslyckad sökning dvs. O(n) i
värsta fall.
• Om elementet redan finns avbryts operationen. Men i värsta fall hittar
man elementet i det mest avlägsna lövet. Därför O(n) även i detta fall.
Borttagning
• Består av två sökningar i värsta fall: Först efter noden som skall tas bort,
sedan efter minsta noden i dess högra underträd.
• Sökningarna tillsammans kan inte kosta mer än längden på den
längsta grenen i trädet dvs. O(n)
• Om det som skall tas bort inte finns blir det en misslyckad sökning dvs.
O(n) i värsta fall även här.
Analys av operationer på BST, medelfall
Den interna väglängden för ett träd T, IPL(T), definieras
som summan av djupet av alla noder i trädet.
Om vi dividerar IPL(T) med antalet noder i trädet, n, får vi
”medeldjupet” för en nod i T.
En lyckad sökning efter en nod x kostar d(x)+1.
En lyckad sökning i trädet kostar alltså i medeltal
IPL(T)/n +1.
Önskvärt: Träd med så liten intern väglängd som möjligt.
AD: Träd 55
AD: Träd 56

Analys av operationer på BST
Man kan visa att för fixt n, så är det minimala värdet på den
interna väglängden för ett binärt träd n*log n. Dessa träd är
enkla att känna igen: De har så fullt av noder som det är möjligt
på varje nivå utom möjligtvis på nivån längs bort från roten.
Analys av operationer på BST
Det maximala värdet av den interna väglängden är
n(n–1)/2 och inträffar för träd med maximal höjd (dvs
träd med bara en nod på varje nivå).
Ex:
Träd med minimal
intern väglängd
Detta träd har inte minimal
intern väglängd
AD: Träd 57
AD: Träd 58
Analys av operationer på BST, medelfall
Analys av operationer på BST, medelfall
Man kan visa att medelvärdet för den interna väglängden för
alla träd med n noder är 1.38n*log n under förutsättning
att alla insättningsordningar för de n nycklarna i trädet är
lika sannolika.
Kostnaden för att söka efter en nod x som finns i trädet är
d(x)+1. Medelkostnaden för att söka någon av de n noderna
är alltså
( (d(x)+1))/n = 1 + IPL(T)/n
Medelkostnaden för en lyckad sökning i ett binärt sökträd är
därför under de givna förutsättningarna:
1 + (1.38 n log n)/n = 1 + 1.38 log n = O(log n).
AD: Träd 59
Insättning = misslyckad sökning. Insättningsplatsen är vid
någon av null-referenserna nere i trädet. Ritade med fyrkant
i figuren:
De noder som ritats ut som kvadrater ovan brukar kallas externa
noder i trädet. Man får alltså fram dem genom att komplettera
trädet så att alla de vanliga noderna i trädet har två barn.
Kostnaden för en insättning är d(x)+1 där x är den externa nod
vid vilken insättningen sker.
AD: Träd 60

Analys av operationer på BST, medelfall
Analys av operationer på BST, medelfall
Den externa väglängden i ett träd T, EPL(T) definieras som
summan av djupet av alla de externa noderna i T.
Enkla samband som kan visas:
• Det finns n+1 externa noder i ett träd med n noder
• EPL(T) = IPL(T) + 2n
Medelkostnaden för en insättning blir
( (d(x)+1))/(n+1) = ( d(x))/(n+1) + ( 1 )/(n+1) =
= EPL(T)/(n+1) + 1 =
= (IPL(T) + 2n)/(n+1) +1
över alla
de n+1
externa
noderna
Dvs i medeltal (1.38n log n + 2n)/(n+1) + 1 = O(log n)
AD: Träd 61
AD: Träd 62
Analys av operationer på BST, medelfall
Om vi gör borttagningar i trädet är det inte längre klart att
alla trädformer blir lika sannolika.
Vid borttagning av nod med två barn gick vi t ex alltid ner i
höger underträd och tog bort en nod där.
Empiriska studier visar att det är rimligt att anta att när man
gör många slumpmässiga insättningar och borttagningar i ett
binärt sökträd får trädet sådan form att medelfallet för alla
operationerna är O(log n).
Men: värstafallet är O(n). Önskvärt: att i samband med
insättning och borttagning kunna se till att trädformen förblir
sådan att även värstafallet blir O(log n).
AD: Träd 63
Balanserade binära sökträd
Mål: Se till att ett binärt sökträd får en sådan form att höjden
är O(log n) oavsett i vilken ordning insättningar och
borttagningar görs.
Det finns inga tillräckligt effektiva algoritmer för att i
samband med insättning/borttagning se till att trädet får
minimal intern väglängd, vilket skulle garantera att höjden
alltid förblir log n
Det finns svagare krav än minimal intern väglängd som
garanterar att höjden blir O(log n) och för vilka det finns
tillräckligt effektiva algoritmer.
AD: Träd 64

Balanserade binära sökträd, AVL-träd
Balanserade binära sökträd, AVL-träd
Ett sådant villkor ställdes upp av Adelson-Velskii och Landis
och träd som uppfyller villkoret kallas därför ofta AVL-träd
(eller bara balanserade träd/ höjdbalanserade träd).
Def:Ettbinärtträdärbalanserat om det för varje nod i trädet
gäller att höjdskillnaden mellan dess båda underträd är högst
ett.
AD: Träd 65
Balanserat (men har inte minimal
intern väglängd)
Ej balanserat
Anm: Träd med minimal intern väglängd (vilka har höjden
log n) är alltid balanserade. Omvändningen gäller ej (se fig
till vänster ovan). Det är alltså ett svagare villkor för ett träd
att vara balanserat än att ha minimal intern väglängd.
AD: Träd 66
Balanserade binära sökträd, AVL-träd
Balanserade binära sökträd, AVL-träd
Man kan visa att:
• I ett balanserat träd med n noder är höjden h ≤ 1.44 * 2 log n
• Det finns algoritmer med värstafallstid O( 2 log n) som i
samband med insättning av en ny nod eller borttagning av en
nod i ett balanserat träd ser till att trädet förblir balanserat.
Algoritmerna för att balansera ett träd kräver att information om
höjdförhållandena mellan vänster och höger underträd lagras i
varje nod. T ex lagras -1 om vänster underträd har en höjd som
är ett större än höger underträd, 0 om de har lika höjd och +1 om
höger underträd har en höjd som är ett större än vänster
underträd.
AD: Träd 67
Balanseringsalgoritmerna arbetar med rotationer i trädet:
x
y
Enkel högerrotation
vid y A
x
y
C
A B
B C
y Enkel vänsterrotation
vid y y
x
x
A
C
B C
A B
AD: Träd 68

Balanserade binära sökträd, AVL-träd
Balanserade binära sökträd, AVL-träd
A
y
z
x
D
Höger-vänsterdubbelrotation
z
y
A B C
x
D
• Obalans som orsakas av en insättning (i ett balanserat
träd) kan alltid repareras genom högst en enkelrotation
eller en dubbelrotation i någon av noderna på vägen från
den nya noden till roten.
B
x
A
B
C
y
z D
C
Vänster-högerdubbelrotation
z
x
A B C
y
D
• Obalans som orsakas av en borttagning (i ett balanserat
träd) kan repareras genom enkla eller dubbla rotationer i
noderna på vägen från den borttagna noden till roten. Här
kan det krävas rotation i varje nod på vägen.
AD: Träd 69
AD: Träd 70
Balanserade binära sökträd, AVL-träd
Balansering av binära sökträd, ex
Tidskomplexitet:
• Vi utgår från ett balanserat träd före
insättningen/borttagningendvsdesshöjdh
• Varje rotation tar konstant tid
O(log n).
Därmed klart att algoritmerna för insättning/borttagning
kombinerade med eventuell balansering blir O( 2 log n)
Ex: Sätt in nycklarna 1, 2, 3, ..., 7 i ett från början tomt
AVL-träd.
Insatt: 1 2 3
1 1
2
1
y
2
x
3
Obalans vid y
Efter enkel vänsterrotation
vid y:
1
2
forts. ....
3
AD: Träd 71
AD: Träd 72

Balansering av binära sökträd, ex
Balansering av binära sökträd, ex
Insatt: 4 5
2
2
1 3
1 3
4
y
4
x
5
Obalans vid y
Efter enkel vänsterrotation
vid y:
2
1 4
3 5
forts …
Insatt: 6
2
1
3
y
4
x
5
6
Obalans vid y
Efter enkel vänsterrotation
vid y:
1
2
4
3
5
6
forts …
AD: Träd 73
AD: Träd 74
Balansering av binära sökträd, ex
Balansering av binära sökträd, ex
Insatt: 7
4
2 5
1 3
y
6
x
7
Obalans vid y
Efter enkel vänsterrotation
vid y:
4
2
1 3 5
6
AD: Träd 75
7
Efter insättning av 15 och 14 (i den ordningen) i det sista
trädet på föregående bild får man trädet:
4
2
1 3 5
Det råder nu obalans vid y
men om man försöker med
en enkel vänsterrotation
blir det
6
y
7
14
15
x
4
2 6
1 3 5 15
7
14
Detta träd är fortfarande
obalanserat! Om man i stället gör en
dubbel höger-vänsterrotation
vid y blir det som på nästa bild.
AD: Träd 76

Balansering av binära sökträd, ex
Balansering av binära sökträd
2
4
1 3 5
6
y
7
15
x
Efter dubbel högervänsterrotation
vid y:
Enkla rotationer räcker i samband med insättning när
obalansen har någon av formerna:
14
z
2
4
1 3 5
6
14
Dubbla rotationer behövs däremot vid obalans av typerna:
7
15
AD: Träd 77
AD: Träd 78
Klassen BinarySearchTree
Exempel på en klass som beskriver ett binärt sökträd:
public class BinarySearchTree> {
public BinarySearchTree() {...}
public void insert(E x) {...}
public void remove(E x) {...}
public E find(E x) {...}
public boolean isEmpty() {...}
}
AD: Träd 79
Ex på användning av BinarySearchTree
Antag vi vill sätta in personuppgifter (namn och telefonnummer)
i ett BST och vi vill hålla det sorterat efter namn.
Vi inför då en klass Person:
class Person implements Comparable {
private String name;
private String address;
public Person(String n, String addr) {...}
public int compareTo(Person rhs) {
return name.compareTo(rhs.name);
}
public boolean equals(Object rhs) {
return compareTo((Person) rhs) == 0;
}
public int getAddress() {...}
}
AD: Träd 80

Ex på användning av BinarySearchTree
Vi kan nu sätta in personer i ett binärt sökträd:
BinarySearchTree reg = new BinarySearchTree();
reg.insert(new Person(”Adam”, ”Paradisgatan 1”));
reg.insert(new Person(”Eva”, ”Paradisgatan 1”));
...
Person p = reg.find(new Person(”Adam”, ””));
if (p != null) {
System.out.println(”Adam´s address: ” + p.getAddress());
} else {
...
AD: Träd 81
ADTn Lexikon
I en ADT Lexikon (Dictionary) skall det finnas följande
operationer:
• Givet nyckel sök upp tillhörande värde
• Sätt in ny nyckel med tillhörande värde
• Ta bort element med viss nyckel
För att söka och för att undersöka att det inte finns dubbletter
vid insättning måste man kräva att nycklarna är av en typ för
vilken jämförelse avseende likhet är definierad. Detta
uppfyller alla objekt i Java (equals).
AD: Träd 82
Interfacet Map i Java
I Java finns interfacet Map som har de operationer som
krävs för ett lexikon:
public interface Map {
boolean containsKey(Object key);
V get(Object key);
V put(K key, V value);
V remove(Object key);
int size();
...// ytterligare operationer för att bl a
...// ta reda på alla värden i samlingen etc.
}
AD: Träd 83
Användning av klass som implementerar
interfacet Map
Antag vi har en klass som implementerar interfacet Map:
class TreeMap implements Map {...}
Ex på användning:
TreeMap aMap =
new TreeMap();
aMap.put(”Kalle”, new Integer(12345));
aMap.put(”Hobbe”, new Integer(6789));
...
Integer phoneNbr = aMap.get(”Kalle”);
if (phoneNbr != null) {
System.out.println(”Kalle has phone number: ” +
phoneNbr.intValue());
AD: Träd 84
}

Javas klasser TreeSet och TreeMap
Javas klasser TreeSet och TreeMap
I java.util finns följande klasser som implementerats med hjälp
av träd och som garanterar O(log n) komplexitet i värsta fall för
sökning, insättning och borttagning:
TreeSet: En klass med ett Set-interface (add, contains,
remove)
TreeMap: En klass med ett Map-interface (get, put, remove)
Båda har implementerats med ett slags balanserade träd,
dock inte AVL-träd utan s.k. röd-svarta träd.
Objekten som sätts in i en TreeSet och nycklarna som sätts
in i en TreeMap måste antingen implementera interfacet
Comparable eller så måste man ha tillhandahållit ett s.k.
Comparator-objekt när trädet konstruerats. Annars får man
exekveringsfel.
Mer om detta på seminarium 4.
AD: Träd 85
AD: Träd 86
Ordningsstatistik
Ordningsstatistik
Problem: Givet en samling element för vilka jämförelse är
definierad. Tag reda på det i storleksordning k:e elementet i
samlingen.
Om k = 1 söker vi alltså det minsta elementet, om k = 2 söker
vi det näst minsta etc.
Om elementen finns insatta i ett BST kan vi lösa problemet
genom att traversera trädet i inorder och stanna efter k steg.
Tidskomplexiteten beror då på k.
AD: Träd 87
Det går att lösa problemet effektivare genom att använda ett
BST där man ser till att noderna i trädet håller reda på sitt
underträds storlek:
class BinaryNodeWithSize extends BinaryNode {
int size; // Antalet noder i underträdet med
// denna nod som rot, inklusive noden själv.
BinaryNodeWithSize(E x) {
super(x);
size = 0; // Kommer att ökas till 1 i samband
// med att noden sätts in som ett
// löv i trädet och sedan uppdateras
// i samband med ytterligare
// insättningar/borttagningar i trädet
}
AD: Träd 88
}

Ordningsstatistik
class BinarySearchTreeWithRank> extends BinarySearchTree {
/** Sök upp det element som är nr k i storleksordning */
public E findKth(int k);
// OBSERVERA att även insert och remove måste omdefinieras
// i denna klass eftersom size-attribut i vissa noder
// behöver uppdateras. Se boken för detaljer.
}
Ex. på ett träd av typ BinarySearchTreeWithRank där enbart
size-attributen i noderna visas: 6
3 2
1 1 1
AD: Träd 89
Ordningsstatistik
Implementationsidé för findKth (med tidskomplexitet som nu
beror enbart på höjden av trädet):
Sök rekursivt med början i roten. Vi får tre fall beroende på
storleken S L (size-attributet ) hos vänster underträd:
•Omk=S L + 1 är vi klara
•OmkS L + 1 så sök det element som är (k – S L –1) i
storleksordning i höger underträd
AD: Träd 90
Ordningsstatistik
Ex: Sök 4:e nyckeln i storleksordning i trädet nedan.
Första talet i en nod anger nyckel, andra talet anger size.
findKth(4)
findKth(4)
2
1
7
5
8
1
9
3
11
7
10
1
12
1
findKth(2). Klart! k = S L
+1
AD: Träd 91
Generaliserade sökträd
Ett m-vägs sökträd är ett träd där
• varje nod har högst m underträd
• nycklarna i en nod är en sekvens av upp till m-1 värden i
stigande ordning som fungerar som delningspunkter vid
sökning
• till en nod med k+1 underträd t 0 ,t 1 ,...,t k hör en sekvens av
k nycklar key 1 < key 2 < ... ,< key k . Sorteringsvillkoret för
trädet är:
alla nycklar i t 0 är mindre än key 1
alla nycklar i t j , för 1

Generaliserade sökträd
Generaliserade sökträd, ex
key1 key2 ...keyk
l,p
e,h
m,n,o
s
a,b,c f,g i,j,k q,r t,u,v
key1
keyk
t 0 t 1 t k
AD: Träd 93
AD: Träd 94
B-träd
B-träd är en typ av balanserat m-vägs sökträd. Det finns flera
varianter. En av dem är följande:
• roten är antingen ett löv eller så har den mellan 2 och m barn
(dvs roten innehåller mellan 1 och m-1 nycklar)
• för varje nod som inte är ett löv (utom möjligen roten) gäller
m/2

1, 2, 3
2-3-träd, ex
Nyckeln 3 sätts först också in i rotnoden, som
då kommer att innehålla en nyckel för mycket.
Noden splittras då i två noder. Mittnyckeln sätts
normalt in i föräldernoden.
Föräldernod finns ej i detta fall varför den bildas.
Resten av nycklarna delas upp på två noder som får
bli vänster resp höger barn till den nya noden:
Split
2
1 3
AD: Träd 97
4 sätts in i rätt löv: 5 sätts in:
2
1 3, 4
Och 7:
2, 4
1 3 5, 6, 7
Split
Problemnod
2-3-träd, ex
2
1 3, 4, 5
Problemnod, splittra.
Problemnod
2, 4, 6
1 3 5 7
2, 4
1 3 5
Split
Efter insättning av 6:
2, 4
1 3 5, 6
AD: Träd 98
2
4
6
1 3 5 7
B-träd, analys
För ett B-träd av ordning m med höjden h och n nycklar insatta
gäller att höjden h = O(log n).
• För att välja rätt underträd för fortsatt sökning krävs att man ”stänger
in” sökt nyckel mellan två nycklar i noden. Nycklarna i en nod
förutsätts lagrade i växande ordning i en vektor. Man kan alltså
använda binärsökning. Kostnaden för sökning i en nod är därför O(log m).
• Nycklar måste också skiftas i den vektor där de lagras i samband med
splittringar. Kostnaden för detta är O(m).
Eftersom m är en konstant blir det O(1) arbete i varje nod vid sökning
och insättning. Antalet noder som berörs är uppåt begränsat av höjden.
==> Värstafallskostnad för sökning och insättning O(log n)
AD: Träd 99
Representation av trädstruktur med
vektor
Träd representeras vanligen av länkade strukturer. Även
vektorer kan användas. Idén bakom vektorrepresentationen
kan sedan användas för att lagra trädstrukturer på fil, vilket
kan vara användbart när man inte kan ha hela trädet i
primärminnet, men vill kunna söka snabbt.
AD: Träd 100

Representation av trädstruktur med
vektor, ex
Lagring av trädstruktur på fil
3
4
2 8
5 9
Kan lagras i en vektor
(Data-delen ej ifylld,
–1 motsvarar null):
left och right är nu heltal som
”pekar” ut den plats i vektorn där
vänster resp. höger barn finns. Man
behöver bara känna till platsen där
roten lagrats för att t ex kunna söka i
trädet.
Roten= 5
0
1
2
3
4
5
6
7
8
9
10
Key Data Left Right
5
2
8
4
3
9
-1 -1
-1 8
1 10
3 4
-1 -1
-1 -1
En fil är logiskt indelad i ett antal numrerade block. Vanlig
blockstorlek är 512 bytes eller större. Ett block utgör den
minsta enhet som kan läsas eller skrivas på fil.
Vid lagring av ett binärt sökträd på fil så placeras i ett block
nyckel, data samt nummer på de block på filen som
innehåller vänster respektive höger underträd (analogt med
hur vektorn används i exemplet på förra bilden). Det enda
man behöver känna till för att börja söka är numret på det
block där roten finns.
AD: Träd 101
AD: Träd 102
Lagring av trädstruktur på fil
Tekniken kräver direktfiler, dvs att det finns operationer för
att läsa och skriva på ett visst block på filen.
Varje gång man går vidare till vänster eller höger underträd
måste man läsa in ett nytt block från filen. Detta är en mycket
mera kostsam operation än jämförelser mellan nycklar.
Lagring av trädstruktur på fil
B-träd kan på analogt sätt lagras på fil. Man kan då välja m
så stort att det maximala antalet nycklar i en nod (m-1),
referenser till deras data, samt blocknummer för det maximalt
antal möjliga underträden får plats och fyller upp ett block.
Typiskt m-värde kan vara 128 eller 256. För så stora m-
värden kan väldigt många nycklar lagras i mycket låga träd t
ex höjden 3 eller 4. Det blir mycket få läsningar av block för
att hitta det man söker.
Utnyttjas t ex i databaser.
AD: Träd 103
AD: Träd 104

ADT lexikon och träd
Genom att använda träd (balanserade binära sökträd eller B-
träd) vid implementation av ADTn lexikon (sökning, insättning,
borttagning) får vi i värsta fall tidskomplexiteten O(log n) för
operationerna när det finns n element i samlingen.
Man kan visa att detta är den undre gränsen för vad man kan
uppnå om de enda operationer man får utföra på nycklarna är
jämförelser.
Det finns andra sätt att utnyttja nycklarna som gör att vi kan
förbättra tidskomplexiteten ytterligare. Vi skall se på en sådan
möjlighet: Hashtabeller
AD: Träd 105
Hashtabeller
Om enbart operationer för sökning, insättning och
borttagning behövs kan vi använda datastruktur som ger
bättre medelfallstider än binära sökträd.
Idé: Element med nycklar 0, 1, 2, 3, ..., n–1 kan placeras i en
vektor, det i:e elementet på plats i.
Tid för insättning, sökning och borttagning blir O(1)
0
0
1 2 3 4 5
--------
--------
n-1
1 2 3 4 5 n-1
Dock: Alla typer av nycklar kan inte användas som index i en
vektor.
AD: Träd 106
Hashtabeller
Hashtabeller i Java
Idé: Avbilda nycklar på heltal.
Nyckel
Hash-funktion h
Tal i intervallet 0..tableSize-1
h avbildar stor mängd nycklar på en liten mängd tal.
Kollisioner oundvikliga.
Bra hashfunktion: Litet förväntat antal kollisioner, sprider
elementen jämt över tabellen.
Bör påverkas av alla delar av nyckeln.
AD: Träd 107
I klassen Object finns följande metod:
/** returns a hash code value for the object */
public int hashCode();
Metoden returnerar ett heltal. För att hamna i rätt intervall kan
sedan % användas. x.hashCode()%tableSize ger ett heltal i
intervallet 0 .. tableSize-1.
Brukligt att omdefiniera hashCode för de objekt man tänker
sätta in i hashtabeller. Man måste se till att två objekt för vilka
equals returnerar true också har samma hashkod för att
sökning i en hashtabell skall fungera.
AD: Träd 108

Sluten hashtabell
Sluten hashtabell, ex
Det finns olika sätt att implementera den grundläggande idén
för hashtabeller. De skiljer sig på dels vilken datastruktur som
används och också på hur de hanterar kollisioner, d.v.s. hur
man hanterar insättning av objekt när det redan finns ett eller
flera insatta objekt med samma hashkod.
I s.k. sluten hashtabell används en vektor för att lagra
elementen. Det finns sedan olika sätt att hantera kollisioner.
Vid linjär teknik sätter man in ett element som kolliderar med
ett annat på första lediga plats efter den där det skulle ha
hamnat om ingen kollision inräffat. Tabellen betraktas därvid
som cirkulär, d.v.s. plats 0 anses komma efter tableSize-1.
AD: Träd 109
Ex: Sätt in talen 1, 8, 27, 64, 125 i en tabell med 7 platser.
Använd hashfunktionen h(x) = x % 7 och linjär teknik vid
kollisioner.
0
1
2
3
4
5
6
1
0
1
2
3
4
5
6
1
8
0
1
2
3
4
5
6
1
8
27
0
1
2
3
4
5
6
1
8
64
27
125
1
8
64
Sökning efter visst element börjar på den plats elementets
hashkod anger och fortsätter eventuellt framåt. Om det
inte påträffas före en ledig plats finns det inte i tabellen.
AD: Träd 110
0
1
2
3
4
5
6
27
Problem med linjär teknik
Linjär teknik ger upphov till primär klustring itabellen.Om
flera objekt har samma hashkod hVal kommer de alla att
ligga i ett kluster kring platsen hVal i tabellen. Även objekt
vars hashvärden är nära hVal kommer att drabbas av
kollisioner och bygga ut klustret.
Ex: hashfunktion x %11. Sätt in talen 3, 14, 25, 36, 5, 16
3 14 25 36 5 16
0 1 2 3 4 5 6 7 8 9 10
Stora kluster gör sökning långsam.
Borttagning i sluten hashtabell vid linjär
teknik
Om vi vid borttagning bara gör platsen tom, leder det till fel
vid sökning. Ex: Tag bort 25 ur tabellen på föregående bild:
3 14 36 5 16
0 1 2 3 4 5 6 7 8 9 10
Om vi nu söker efter 5 vars hashkod är 5 börjar vi pröva
plats 5. Eftersom denna plats är tom sluter vi oss felaktigt
till att det sökta ej finns i tabellen.
AD: Träd 111
AD: Träd 112

Borttagning i sluten hashtabell vid linjär
teknik
Om vi i stället markerar platsen ”icke-aktiv” vid borttagning (
i fig. nedan markerat med ett d):
3 14 d 36 5 16
0 1 2 3 4 5 6 7 8 9 10
så kan vi utföra sökningen med början på den plats
hashkoden anger och framåt över alla upptagna och ickeaktiva
platser.
Först när vi stöter på en riktigt tom plats är det misslyckad
sökning.
AD: Träd 113
Tidskomplexitet, linjär teknik
Värstafallet för samtliga operationer är O(n), där n är antalet
element som finns insatta i tabellen.
Inträffar om alla element hamnar i en följd och vi t ex vid
sökning måste pröva alla platserna i denna följd.
Är dock ytterst osannolikt.
Under förutsättning att tabellen inte fylls till mer än en viss del
får man emellertid O(1)-komplexitet i medeltal för operationerna.
(Se följande bilder).
AD: Träd 114
Tidskomplexitet, linjär teknik
Man definierar en (sluten) hashtabells fyllnadsgrad (load
factor) som kvoten mellan antal insatta element och antal
platser i tabellen.
En tom tabell har fyllnadsgrad 0 och en full tabell har
fyllnadsgrad 1. Man brukar beteckna fyllnadsgraden med λ .
Man kan visa att: (se nästa bild)
AD: Träd 115
Tidskomplexitet, linjär teknik
• Medelantalet platser som måste prövas vid en insättning
och misslyckad sökning när man använder linjär teknik är
uppåt begränsat av
( 1 + 1/(1 – λ) 2 )/2
Ex. Om λ = 0.5 blir det i medeltal 2.5
• Medelantalet platser som prövas vid en lyckad sökning är
uppåt begränsat av
(1 + 1/(1 - λ))/2
Ex. Om λ = 0.5 blir det i medeltal 1.5
Men: vid hög fyllnadsgrad blir operationerna långsamma när
den linjära tekniken används.
AD: Träd 116

Sluten hashing med kvadratisk teknik vid
kollisioner
Kvadratisk teknik:
● Alternativ, bättre teknik för hantering av kollisioner
● Först prövas nästa plats, sedan platsen 4 steg fram,
sedan 9 steg fram, alltså H, H+1, H+4, ... H+i 2 ,...,där
H är elementets hashkod. Tabellen används fortfarande
cirkulärt.
● Undviker primär klustring av element. Kan modifieras
till andra sekvenser av steg.
Sluten hashing med kvadratisk teknik vid
kollisioner
Ex: Sätt in talen 89, 18, 49, 58, 9 i en tabell med 10 platser.
Hashfunktion: x%10
89%10 = 9, 18%10=8, 49%10=9, 58%10=8, 9%10=9
49 58 9
18 89
0 1 2 3 4 5 6 7 8 9
AD: Träd 117
AD: Träd 118
Sluten hashing med kvadratisk teknik vid
kollisioner
Sluten hashing med kvadratisk teknik vid
kollisioner
Problem: Inte alltid säkert att man hittar ledig plats även om
det finns. Om t ex tabellens storlek är 16 och man använder
hashfunktionen x%16 och sätter in talen 0, 16, 32 och 64 så
kan man inte därefter hitta någon ledig plats för tal som
hashas till plats 0. De enda platser som kommer att prövas i
serien H+i 2 när H=0 blir de upptagna platserna 0, 1, 4 och 9.
AD: Träd 119
Man kan visa att
• Om kvadratisk teknik används och tabellens storlek är ett
primtal så kan ett nytt element alltid sättas in om tabellens
fyllnadsgrad är mindre än 0.5
• Det har ännu inte gjorts någon fullständig analys av
komplexiteten hos operationerna på tabellen när kvadratisk
teknik används. I praktiken visar sig kvadratisk teknik ge
upphov till mindre klustring än den linjära tekniken och
därmed snabbare operationer. (Dock fortfarande O(n) i
värsta fall).
AD: Träd 120

Öppen hashtabell (separate chaining)
Öppen hashtabell (separate chaining)
Elementen i tabellen är listor. I lista nummer i ligger alla
element vars nyckel hashfunktionen avbildar på i.
Ex: Sätt in 7, 9, 14, 12, 21, 19 i en öppen tabell med 7
ingångar. Använd hashfunktionen f(x) = x % 7
0
1
2
tableSize-2
tableSize-1
0
1
2
3
4
5
6
7
9
12
14
19
21
AD: Träd 121
AD: Träd 122
Tidskomplexitet, öppen hashing
Tidskomplexitet, öppen hashing
Värstafall: O(n) för samtliga operationer. Inträffar när alla de
n insatta elementen hamnat i samma lista.
Medelfall: Antag att vi har n insatta element fördelade på de
tableSize olika listorna.
Insättning av nytt element x: Antag att det är lika sannolikt att
x hashas till var och en av listorna. Eftersom den lista (k)
där x skall placeras måste genomletas efter dubblett först så
kostar själva insättningen där = antalet element i listan k. I
medelfall blir det: (forts)
AD: Träd 123
tableSize-1
A(n) = Σ(längden av lista i)/tableSize = n/tableSize
i=0
Spec: Om n tableSize är A(n) = 1
Misslyckad sökning = insättning. Lyckad sökning kan
visas i medeltal kosta:
(n-1)/(2*tableSize) +1.
Tumregel för öppen tabell: Inte fler än 2*tableSize
element bör sättas in.
AD: Träd 124

Sammanfattning om olika
implementationsalternativ för lexikon
Lista: Bara om antalet element förväntas bli litet. Annars
ineffektivt.
BST: Bra medelfall O(log n) för operationer, men dåligt
värstafall, O(n). Måste balanseras för att uppnå O(log n)
även i värsta fall.
B-träd: När man måste lagra träden på sekundärminne. I
primärminne används de nästan bara i specialfallet 2-3-träd,
som alternativ till balanserade BST.
Hash-tabell: Väldigt bra medelfall O(1) men dåligt värstafall, O(n). Kan
inte väljas om sådant värstafall inte kan tillåtas. Inte heller
om man vill ha ytterligare operationer såsom ”sök minsta”
eller andra som bygger på elementens inbördes
storleksordning.
AD: Träd 125
Hashtabeller i Java
I klassen java.util finns klassen HashMap som implementerar
interfacet Map. Till skillnad från klassen TreeMap så måste inte
de insatta nycklarna ha någon ordningsrelation definierad,
däremot behöver man oftast omdefiniera metoderna
public int hashCode() och
public boolean equals(Object x)
så att man får identisk hashkod för objekt som är lika enligt
metoden equals.
Anm: För flera av Javas egna klasser är detta redan gjort. T ex
klassen String.
AD: Träd 126
Användning av HashMap
Användning av HashMap
Antag vi vill vill sätta in Person-objekt i en hashtabell, med
nyckel = personens namn:
class Person {
String name; // namn
long pNbr; // personnummer
... // övriga attribut
public Person(String n, int pnbr) {...}
public boolean equals(Object rhs) {
return name.equals(((Person) rhs).name);
}
// andra metoder i klassen Person
HashMap reg =
new HashMap();
Person p = new Person(”Kalle”, 1111111111);
reg.put(p.name, p);
...
Person q = reg.get(”Kalle”);
if (q != null) {
…
}
Observera att vi här inte behöver omdefiniera hashCode
eftersom nycklarna är av typen String, och man i denna klass
redan gjort detta.
} AD: Träd 127
AD: Träd 128

Klassen HashSet i Java
Användning av HashSet
Det finns ytterligare en klass i java.util som utnyttjar
hashtabeller för sin implementation, klassen HashSet. Den
implementerar interfacet Set och de viktigaste operationerna
är:
boolean add(E x);
boolean contains(Object x);
boolean remove(Object x);
Iterator iterator();
Det finns alltså ingen riktig sökoperation.
AD: Träd 129
Om vi vill sätta in Person-objekt i en samling av typen
HashSet och gör så här:
HashSet reg = new HashSet();
Person p = new Person(”Kalle”, 1111111111);
reg.add(p);
...
if (reg.contains(new Person(”Kalle”,0)) {
System.out.println(”found”);
} else {
System.out.println(”not found”);
}
så blir utskriften med största sannolikhet ”not found”.
AD: Träd 130
Användning av HashSet
Anledningen är att när Kalle sätts in beräknas hashkoden för
objektet som p refererar till och placeringen i tabellen beror
på denna. När vi sedan söker efter Kalle baseras sökningen
på hashkoden av det objekt som är parameter till containsmetoden
och detta är ett annat objekt (med samma namn).
Sökningen utgår från den plats denna senare hashkod anger
och med största sannolikhet är det i en helt annan del av
tabellen än den där Kalle sattes in.
AD: Träd 131
Användning av HashSet
Vi kan se till att alla Person-objekt som har samma namn
också får samma hashkod genom att omdefiniera metoden
hashCode i klassen Person:
class Person {
String name; // namn
long pNbr; // personnummer
... // övriga attribut
public Person(String n, int pnbr) {…}
public boolean equals(Object rhs) {som förut}
public int hashCode() {
return name.hashCode();
}
// övriga metoder i klassen Person
}
AD: Träd 132