TDDC30
Objektorienterad programmering i Java, datastrukturer och algoritmer. Föreläsning 8
Erik Nilsson, Institutionen för Datavetenskap, LiU
På denna föreläsning:
•
Träd
•
Traversering
•
Insättning, borttagning
•
Representation som länkad nod, array
1
Scenario
• Harry har fått i uppdrag att bringa ordning
och reda till ett företags chefstruktur med ett
nytt program
• Harry börjar med att skriva in alla anställda i
en enkellänkad lista, men det blir snabbt krångligt
• En ny datastruktur behövs!
2
Grafteori
• En graf
Sverige
Norge
Finland
• Består av noder & bågar
• T.ex. länder och sina grannar…
• En riktad graf
• Sätter riktning på bågarna
Vakna
På morgonen
Gå till
sängs
• T.ex. Ett tillståndsdiagram
• En riktad acyklisk graf (DAG)
Gå till jobbet
Jobba
Gå hem
Agnes
• Innehåller inga cykler
• T.ex. Ett släktträd.
Laura
Erik
Torbjörn
Tracy
3
Träd
Definition (datastruktur*):
• Ett träd är en riktad acyklisk graf (DAG)
• och det finns enn väg till varje nod
Vanliga användningsområden:
• Representering av hierarkier (ex):
• Organisationer
• Släktträd (DAG)
• Filsystem(mappar/filer)
• Spara data för snabb sökning
*Inom grafteorin är träd en acyklisk oriktad graf.
4
Scenario
• Harrys resultat:
VD Adam Adamsson
Utvecklingschef Berta
Bengtsson
Säljchef Caesar
Cesarini
Ekonomichef Diana
Didriksson
Hackaren Harry
5
Träd(2)
Definition:
• Förälder: en nod som har minst ett barn
• Syskon: noder med samma förälder
• Rot: en nod utan förälder
• Löv: en nod utan barn
• Gren/delträd: en samling noder
med gemensam anfader
Rot
Förälder
Barn
Syskon
Gren
Löv
6
• Träd defineras rekursivt: Ett delträd är också ett träd, som kan
innehålla fler delträd, eller bara en nod (d.v.s. ett löv)
Träd(3)
Nodinformation:
• Grad: Antal barn noden har
• Djup: Avstånd från roten
• Höjd: Avstånd till lövet längst bort, nedåt
Djup
0
• Trädets höjd = Rotens höjd
1
2
3
• Träd med noder av grad ≤ 2: Binärt träd
Grad: 2
Djup: 1
Höjd:2
7
ADT Träd
element()
Returnerar datat i rotnoden (för delträdet)
parent()
Returnerar föräldranoden (implementeras inte alltid)
children()
Returnerar en kollektion(t.ex. en lista) med nodens barn
isInternal()
Testar om noden är en inre nod d.v.s. om den har barn
isExternal(),
isLeaf()
Testar om noden är en yttre nod d.v.s. om den är ett löv
isRoot()
Returnerar sant om noden ej har någon förälder
isEmpty()
Testar om (del)trädet har några noder överhuvudtaget
Binära träd
left()
Returnerar det vänstra barnet
right()
Returnerar det högra barnet
hasLeft()
Testar om noden har ett vänsterbarn
hasRight()
Testar om noden har ett högerbarn
8
Traversering
• Traversering: Ett systematiskt sätt att ”besöka”
alla noder i ett träd
• En träd-iterator implementerar någon form av
traverseringsalgoritm
• Djupet-först
• Bredden-först
9
Preorder-traversering
Algoritm:
1. Besök mig
2. Besök vänstra delträdet
3. Besök högra delträdet
= Delträd
10
Inorder-traversering
Algoritm:
1. Besök vänstra delträdet
2. Besök mig
3. Besök högra delträdet
= Delträd
11
Postorder-traversering
Algoritm:
1. Besök vänstra delträdet
2. Besök högra delträdet
3. Besök mig
= Delträd
12
Levelorder-traversering
Algoritm:
1. Besök mig
2. Besök mina syskon till höger
3. Besök de som har djup + 1
Djup
0
1
2
3
13
Några fler termer
• Fullt binärt träd:
Samtliga noder har noll eller två barn
• Perfekt träd:
Ett fullt träd med alla löv på samma djup
• Fullständigt binärt träd:
Ett perfekt träd med skillnaden att den får
sakna några av de ”högraste” löven,
längst ned
14
Binärt sökträd
• En typ av binärt träd
• En struktur för snabb sökning
För varje nod gäller följande:
• Alla element till vänster
är mindre än nodens värde
• Alla element till höger
är större än nodens
värde
-
+
+
-
-
• Nackdel: kan inte spara två element med samma värde.
15
Binärt sökträd
• Sökning går snabbt!
• Hur snabbt? - Vi fokuserar på balanserade träd och kollar på vad
som händer när n ökar:
n = 15
n=3
=> max 1 ”steg”
=> max 3 ”steg”
n=7
=> max 2 ”steg”
Allmänt fall:
För ett balanserat träd blir
det maximala antalet steg
som vi måste gå för att hitta
vårt sökta värde lika med
trädets höjd => O(log(n))
16
Addering i binärt sökträd
För varje nod som besöks:
• Existerar ej noden: Rätt plats funnen
• Är värdet mindre än nodens: följ
den vänstra grenen
• Är värdet större än nodens:
följ den högra grenen
-
+
+
-
-
17
Borttagning i binärt sökträd
Steg 1, 2, 3:
Mål: ta bort värdet 3
Strategi:
1. Sök ut rätt nod på liknande
sätt som vid adderingen
2. Sök reda på en ersättare:
1.
2.
1
-
4
1
-
2
7
+
+
-
6
-
9
8
5
4
-
3
2
Om bara ett barn finns, välj det
Annars välj noden längst till
vänster i det högra delträdet. Steg 4:
3. Koppla loss ersättaren,
ersätt den med dess högra
delträd om ett sådant finns
4. Sätt in ersättaren på dess
nya plats
-
3
5
+
6
7
+
8
9
18
Borttagning i binärt sökträd(2)
Det färdiga trädet efter borttagningen
-
1
2
4
-
+
7
+
6
9
8
5
19
Representation
• Träd brukar vanligtvis implementeras som länkade noder
Parent(optional)
data
left
right
20
Representation(2)
Parent(optional)
data
left
right
• Kodexempel, som generisk klass
class TreeNode<DataType> {
TreeNode parent;
DataType data;
TreeNode left;
TreeNode right;
}
21
Representation(3)
Parent(optional)
data
left
right
• Då delträd också är träd lämpar sig strukturen
väl för rekursiva algoritmer
Exempel: Preorder-traversering
public void visitPreorder(TreeNode node){
node.visitMe();
visitPreorder(node.left());
visitPreorder(node.right());
}
22
Representation(4)
Parent(optional)
data
left
right
• Stackar och köer kan också användas för
traversering
Exempel: Levelorder-traversering
(Börja med att lägga roten i en kö)
1. Hämta en nod från kön
2. Besök noden
3. Lägg vänster och höger barn i kön
4. Repetera så länge kön inte är tom
23
Representation med fält
• Träd kan även implementeras med ett fält!
A
ADT
B
D
G
C
E
Representation
A B C D E F
G
H
F
H
Traverseringsregler för binärt träd:
Index för root
0
Index för vänster barn
2*i+1
Index för höger barn
2*i+2
Index för förälder
(i-1)/2 (avrunda nedåt)
24
Implementation som fält(2)
Egenskaper för fältrepresentation
• Slipper tre pekare per element
AB CD E F
G
H
• Mindre minne
• Traversera m.h.a. aritmetiska operationer (2*i + 1)
• Minne kan preallokeras (vanligtvis ett träddjup i taget)
• Fält allokeras som sammanhängande stycken av datorminne
• => Hög spatial lokalitet => Snabbt
• Varje new är ett anrop till OS för att be om minne, tar tid
• Tenderar att bli svårare att implementera
• Ett dåligt balanserat träd ger ineffektivt minnesutnyttjande
25
