Kap 09 Tre

Slektstre Slektstre med ulike generasjoner (foreldre, barn, barnebarn, …)

Student-opplysninger Trestruktur med studentopplysninger (fødselsnr, navn, adresse, kurs, eksamener) Subtre er en del av et tre og er selv et tre

Filkataloger Filkataloger

Kompilering Kompilering av program ved programsplitting i en trestruktur void main ( ) { int a,b; cout << ”Oppgi a: ”; cin >> a; cout << ”Oppgi b: ”; cin >> b; if(a>b) cout << ”Største tall: ” << a; else cout << ”Største tall: ” << b; }

Tre - Definisjon Et tre T er en endelig mengde av noder med følgende egenskaper: 1. Enten er mengden tom, T = Ø, eller 2. Mengden består av en node R kalt rot og de resterende nodene er partisjonert i n >= 0 såkalte subtrær T1, T2, …, Tn hvor hver Ti selv er et tre. T = {R} U T1 U T2 U … U Tn = {R, T1, T2, …, Tn}

Tre - Eksempler T = {A} T = {A, {B}} D T = {A, {B, {C}}, {D, {E, {F}}, {G}, {H}}} C E G H F

Tre - Definisjoner T = {R, T1, T2, …, Tn} Graden til en node er antall subtre assosiert med denne noden. Et løv er en node med grad null (har ingen subtre). Hver rot Ri i subtreet Ti til treet T kalles et barn til R. Tilsvarende defineres barnebarn, … . Roten R i treet T kalles foreldreelement til alle røttene Ri i subtreet Ti 1 < i <= n. Tilsvarende defineres besteforeldre. To røtter Ri og Rj av distinkte subtrær Ti og Tj i treet T kalles søsken.

Tre - Eksempler Graden til A er 2 Graden til B er 1 Graden til C er 0 Graden til D er 3 C, F, G og H er løv B og D er barn til A C, E, G og H er barnebarn til A F er barn til E A er foreldreelement til B og D B og D er søsken E, G og H er søsken B D C E G H F

Tre - Definisjoner Gitt et tre T med en mengde V av noder. En vei P i T er definert som en ikke-tom sekvens av noder P = {v1, v2, …, vk} hvor vi V for 1 <= i <= k slik at den i-te noden vi er foreldreelement til den (i+1)-te noden vi+1. Lengden av veien P er k-1. A Veien P = {A, D, E, F} har lengde 3. Veien P = {D,H} har lengde 1. Veien P = {B} har lengde 0. B D C E G H F

Tre - Definisjoner Gitt et tre T med en mengde V av noder. Nivået eller dybden til en node vi V i T er definert som lengden av den entydige veien i T fra roten R til noden vi. Høyden til en node vi V i T er definert som den lengste veien fra noden vi til et løv. Høyden til et tre T er definert som høyden til roten R. La vi og vj V. vi sies å være en forgjenger til vj hvis det finnes en vei fra vi til vj. vi og vj kan være samme node. vi sies å være en ekte forgjenger til vj hvis det finnes en vei med lengde ulik null fra vi til vj. Tilsvarende defineres etterfølger og ekte etterfølger.

Tre - Definisjoner Nivået til A er 0 Nivået til B er 1 Nivået til C er 2 Nivået til F er 3 Høyden til A er 3 Høyden til B er 1 Høyden til C er 0 Høyden til F er 0 Høyden til G er 0 Høyden til treet T er lik høyden til A, dvs 3 D er forgjenger (også ekte forgjenger) til E D er forgjenger (også ekte forgjenger) til F D er forgjenger til D G er etterfølger (også ekte etterfølger) til A G er etterfølger til G B D C E G H F

N-ary Tre - Definisjon Et N-ary tre T er et tre hvor alle nodene har samme grad N. T = {R, T0, T1, …, TN-1} hvor hver Ti er et N-ary tre Det tomme treet kalles en ekstern node fordi det ikke har noe subtre. Et ikke-tomt tre kalles en intern node. Et løv er en intern node som kun har eksterne subtrær.

N-ary Tre - Eksempel Tertiær tre (N = 3) T = {A,Ø,Ø,Ø} A T = {A,{B,Ø,Ø,Ø},Ø,Ø} B = Ø = tomt tre

N-ary Tre - Teorem 9.1 Teorem 9.1: Et N-ary tre med n >= 0 noder inneholder (N-1)n+1 eksterne noder. Bevis: La antall eksterne noder være e. Siden hver node unntatt roten (tom eller ikke) har ett foreldreelement, må det være (n+e-1)/N foreldreelementer i treet siden hvert foreldreelement har N barn. Herav har vi: n = (n+e-1)/N som gir e = (N-1)n+1.

N-ary Tre - Teorem 9.1 - Eksempel B D C E G H F N = 3 Interne noder : n = 8 Eksterne noder : e = (N-1)n+1 = (3-1)8+1 = 17

N-ary Tre - Teorem 9.2 … … Teorem 9.2: 1 k k+1 … … Teorem 9.2: La T være et N-ary tre med høyde h >= 0. Maksimalt antall interne noder i T er da gitt ved: (Nh+1-1)/(N-1) Bevis: (ved induksjon) La T være et N-ary tre med høyde null. Det består av en intern node og N tomme subtrær. Teoremet holder derfor for h = 0 siden (N0+1-1)/(N-1) = (N-1)/(N-1) = 1. Anta at teoremet holder for h = 0,1,2,…,k hvor k >= 0. La T være et N-ary tre med høyde k+1. Et slikt tre består av en rot og N subtrær hver inneholdene høyst (Nk+1-1)/(N-1) interne noder. Maksimalt antall interne noder er derfor: N(Nk+1-1)/(N-1)+1 = (Nk+2-1)/(N-1)

N-ary Tre - Teorem 9.2 - Eksempel Høyde = 3 Maksimalt antall interne noder = (33+1 - 1)/(3-1) = 80/2 = 40

N-ary Tre - Corollar 9.2 Corollar 9.2: La T være et N-ary tre med høyde h >= 0. Maksimalt antall eksterne noder i T er da gitt ved: (N-1)(Nh+1-1)/(N-1) + 1 = Nh+1 nmax Hint (fra teorem 9.1): emax = (N-1)nmax + 1

N-ary Tre - Corollar 9.2 N = 3 Høyde = 3 Maksimalt antall eksterne noder = Nh+1 = 33+1 = 34 = 81

N-ary Tre - Teorem 9.3 … … Teorem 9.3: 1 k k+1 … … Teorem 9.3: La T være et N-ary tre med høyde h >= 0. Maksimalt antall løv noder i T er da gitt ved: Nh Bevis: (ved induksjon) La T ha høyde null. T består av nøyaktig en node som har N tomme subtrær. Den ene noden er derfor et løv. Teoremet holder for h = 0 siden N0 = 1. Anta at teoremet holder for h = 0,1,2,…,k. La T ha høyde k+1. Foruten en rot R består T av N subtrær som hver har høyest Nk løv. Maksimalt antall løv er derfor N x Nk = Nk+1

N-ary Tre - Teorem 9.3 N = 3 Høyde = 3 Maksimalt antall løv = Nh = 33 = 27

Binært tre - Definisjon Et binært tre er et N-ary tre hvor N = 2, dvs hver node har eksakt to barn (uten eksterne noder maksimalt to barn). T = {R, TL, TR} TL og TR kalles for henholdsvis venstre subtre og høyre subtre. A A B C B C = D D

Tre gjennomløping Tre gjennomløping: - Bredde først gjennomløp A B D Tre gjennomløping: - Bredde først gjennomløp - Dybde først gjennomløp - PreOrden gjennomløp - InOrden gjennomløp (kun for binært tre) - PostOrden gjennomløp C E H F

Tre gjennomløping Bredde først Bredde først gjennomløp: Gjennomløping etter nivå: 0,1,2,... A A - B - D - C - E - G - H - F B D C E G H F

Tre gjennomløping Dybde først PreOrden PreOrden gjennomløp: 1. Besøk roten 2. PreOrden gjennomløp av subtrærne til roten A B D A - B - C - D - E - F - G - H C E G H F

Tre gjennomløping Dybde først PreOrden (for binært tre) PreOrden gjennomløp: 1. Besøk roten 2. Gjennomløp venstre subtre 3. Gjennomløp høyre subtre A B D A - B - C - D - E - F - H C E H F

Tre gjennomløping Dybde først InOrden (kun for binært tre) InOrden gjennomløp: 1. Gjennomløp venstre subtre 2. Besøk roten 3. Gjennomløp høyre subtre A B D C - B - A - F - E - D - H C E H F

Tre gjennomløping Dybde først PostOrden PostOrden gjennomløp: 1. PostOrden gjennomløp av subtrærne til roten 2. Besøk roten A B D C - B - F - E - G - H - D - A C E G H F

Tre gjennomløping Dybde først PostOrden (for binært tre) PostOrden gjennomløp: 1. Gjennomløp venstre subtre 2. Gjennomløp høyre subtre 3. Besøk roten A B D C - B - F - E - H - D - A C E H F

Tre gjennomløping Dybde først Oppsummering: Pre- / In- / Post-Orden (for binært tre) PreOrden 1. Roten 2. Venstre subtre 3. Høyre subtre InOrden 1. Venstre subtre 2. Roten 3. Høyre subtre PostOrden 1. Venstre subtre 2. Høyre subtre 3. Roten 1 2 3 2 3 1 3 1 2 A-B-C-D-E-F-H C-B-A-F-E-D-H C-B-F-E-H-D-A A B D C E H F

Operator Aritmetisk tre Operand Operand Et aritmetisk tre er et binært tre hvor hver node enten er en operand eller en binær operator. I et subtre bestående av rot, venstre subtre og høyre subtre, vil roten bestå av den operatoren som skal virke mellom de to operandene plassert som venstre og høyre subtre. ( a - b ) + c * ( e / f )

Traversering av et binært tre Aritmetisk tre Preorder traversal : + - a b * c / e f 1. Besøk roten 2. Gjennomløp venstre subtre 3. Gjennomløp høyre subtre ( a - b ) + c * ( e / f ) Inorder traversal : ( a - b ) + c * ( e / f ) 1. Gjennomløp venstre subtre 2. Besøk roten 3. Gjennomløp høyre subtre Postorder traversal : a b - c e f / * + 1. Gjennomløp venstre subtre 2. Gjennomløp høyre subtre 3. Besøk roten

Aritmetisk tre InOrden gjennomløp 1. Skriv venstreparentes 2. Gjennomløp venstre subtre 3. Skriv roten 4. Gjennomløp høyre subtre 5. Skriv høyre parentes (( a - b ) + (c * ( e / f ))) ( a - b ) + c * ( e / f )

Lineær implementering av binært tre Vi kan representere et binært tre med høyde h vha en en-dimensjonal tabell med størrelse 2 h+1 - 1 Nodene lagres på følgende måte: 1. Lagre roten i lokasjon nr 1. 2. Hvis en node er lagret i lokasjon nr n, så skal venstre barn lagres i lokasjon nr 2n og høyre barn i lokasjon nr 2n+1.

Lineær implementering av binært tre Aritmetisk tre ( a - b ) + c * ( e / f )

Lineær implementering av binært tre Aritmetisk tre ( a - b ) + c * ( e / f ) Fordeler: - Enkel sammenheng mellom far/barn. Far i lokasjon n => barn i lokasjon 2n og 2n+1. Et barn i lokasjon n => far i lokasjon n DIV 2. - Kan lett implementeres i alle språk. Ulemper: - Kan medføre plass-sløsing. - Kan medføre mye flytting ved. innsetting/sletting.

Heap Heap er hensiktsmessig bl.a. ved sortering, prioritetskø og komprimering En heap er en trestruktur med følgende undergrupper: MaxHeap Generelt tre hvor hver node har nøkkelverdi større enn eller lik nøkkelverdi til hvert av sine barn MaxBinHeap Binært tre MinHeap Generelt tre mindre enn eller lik nøkkelverdi til hvert av sine barn MinBinHeap Binært tre hvor hver node har nøkkelvedi 8 5 7 4 3 2 6 1 8 5 7 3 2 6 1 2 5 3 9 6 8 4 7 2 5 3 7 9 4 8

Heap Binary Heap Benytter lineær implementering med innsetting fra venstre, nivå for nivå MaxBinHeap Binært tre hvor hver node har nøkkelverdi større enn eller lik nøkkelverdi til hvert av sine barn MinBinHeap hvor hver node har nøkkelvedi mindre enn eller lik nøkkelverdi til hvert av sine barn

Heap Insert to a max binary heap 1. Adder nytt element til bunnen av heap’en. 2. Sammenlign nytt element med foreldre-element. Hvis korrekt rekkefølge, stopp. 3. Hvis ikke korrekt rekkefølge, bytt nytt element med foreldre-element og fortsett i pkt 2.

Heap Insert to a max binary heap - Algorithm Insert_MaxBinHeap (a,n,x) n := n + 1 a[n] := x child := n parent := n div 2 WHILE parent >=1 DO IF a[parent] < a[child] THEN swap(a[parent],a[child]) child := parent parent := parent div 2 ELSE parent := 0 // stop ENDWHILE

Heap Delete from a max binary heap 1. Kopier roten i heap’en. 2. Erstatt roten med siste element i siste nivå. Hvis korrekt rekkefølge, stopp. 3. Hvis ikke korrekt rekkefølge, gjennomfør ’buble-down’ (swap med det største barnet), inntil heap-egenskapen er gjenopprettet.

Heap Delete from a max binary heap Delete_MaxBinHeap (a,n,top,empty) IF (n == 0) THEN empty := true ELSE empty := false top := a[1] a[1] := a[n] n := n – 1 parent := 1 child := 2 WHILE (child <= n – 1) DO IF (a[child] < a[child+1]) THEN child := child + 1 ENDIF IF (a[child] > a[parent]) THEN swap(a[parent],a[child]) parent := child child := 2*child child := n // stop ENDWHILE

Heap Building a max binary heap - Algorithm 4 8 3 2 7 5 Gitt en array a[1..n] av elementer i vilkårlig rekkefølge. Induksjon: 1. a[1] er en heap 2. Anta at a[1..k] er en heap 3. Tilordning av a[1..k+1] til en heap Benytt Insert_MaxBinHeap til å innsette element nr k+1 i heap a[1..k] 4 8 3 2 7 5 8 4 8 4 8 4 3 8 4 3 2 8 7 3 2 4 8 7 5 2 4 3 8 4 3 8 4 3 2 8 7 3 2 4 Build_MaxBinHeap (a,n) FOR i := 2 TO n DO Insert_MaxBinHeap(a,i-1,a[i]) ENDFOR 8 7 5 2 4 3

Heap Rearrange a max binary heap - Algorithm Rearrange_MaxBinHeap (a,n) child := n parent := n div 2 WHILE parent >=1 DO IF a[parent] < a[child] THEN swap(a[parent],a[child]) child := parent parent := parent div 2 ELSE parent := 0 // stop ENDWHILE Insert_MaxBinHeap (a,n,x) n := n + 1 a(n) := x Rearrange_MaxBinHeap(a,n+1)

Heap HeapSort - Algorithm [1/2] HeapSort_MaxBinHeap (a,n) Build_MaxBinHeap(a,n) FOR (i := n DOWNTO 2) DO swap(a[1],a[i]) Rearrange_MaxBinHeap(a,i-1) ENDFOR 4 8 3 2 7 5 8 7 5 2 4 3 8 7 5 2 4 3 swap Rearrange i = 6 3 7 5 2 4 8 7 4 5 2 3 8 i = 5 3 4 5 2 7 8 5 4 3 2 7 8 i = 4 2 4 3 5 7 8 4 2 3 5 7 8 i = 3 3 2 4 5 7 8 3 2 4 5 7 8 i = 2 2 3 4 5 7 8 2 3 4 5 7 8

Heap HeapSort - Algorithm [2/2] 8 7 5 2 4 3 8 7 5 2 4 3 swap Rearrange i = 6 3 7 5 2 4 8 7 4 5 2 3 8 i = 5 3 4 5 2 7 8 5 4 3 2 7 8 i = 4 2 4 3 5 7 8 4 2 3 5 7 8 i = 3 3 2 4 5 7 8 3 2 4 5 7 8 i = 2 2 3 4 5 7 8 2 3 4 5 7 8 3 7 5 2 4 8 7 4 5 2 3 8 3 4 5 2 7 8 5 4 3 2 7 8 2 4 3 5 7 8 4 2 3 5 7 8 3 2 4 5 7 8 3 2 4 5 7 8 2 3 4 5 7 8 2 3 4 5 7 8

Data-komprimering Ascii-tabell Skrivbare tegn Ascii-kode: 0-255 28 = 256 0-127 27 = 128 Skrivbare tegn Binært Dec Tegn 010 0000 32 Space 010 0001 33 ! … 010 1000 40 ( 100 0001 65 A 100 0010 66 B 100 0011 67 C 110 0001 97 a 110 0010 98 b 110 0011 99 c

Data-komprimering Binært Dec Tegn 010 0000 32 Space 010 0001 33 ! … 010 0001 33 ! … 010 1000 40 ( 100 0001 65 A 100 0010 66 B 100 0011 67 C 110 0001 97 a 110 0010 98 b 110 0011 99 c 0 1 00 01 10 11 000 001 010 011 100 101 110 111 … H a l l o Hallo 10010000 1100001 1101100 1101100 110 1111

Data-komprimering Huffman encoding - Prioritetskø vha Heap La vanlige tegn ha korte bitsekvenser, mens uvanlige tegn får lange bitsekvenser Tegn Frekvens A 5 B 2 C 3 D 4 E 10 F 1 F 1 D 4 B 2 A 5 E 10 C 3 MinBinHeap

Data-komprimering Huffman encoding - Prioritetskø vha Heap insert all elements into a minBinHeap H according to their frequencies WHILE H is not empty DO IF H contains only one X element THEN make X the root of binary tree T ELSE pick two elements X and Y with lowest frequencies and delete them from H insert a new element Z with f(Z) = f(X) + f(Y) into H insert a new element Z with children X an Y and f(Z) = f(X) + f(Y) into T ENDIF ENDWHILE Z5 25 E 10 Z 4 15 Z2 6 Z3 9 Z1 3 C 3 D 4 A 5 F 1 B 2 E 0 1 10 11 100 C 101 D 110 A 111 F 1000 B 1001

Symbolsk derivasjon Derivasjon benyttes til å beskrive prosessendringer Typer av diff.lign. ODE Ordinære Endringer mht en enkelt variabel PDE Partielle Endringer mht flere variabler Newtons 2.lov Radioaktivitet Kvantefysikk SHM Varmetransport Bølger Elektrisk krets Studier av svingninger (spesielt resonans) for å hindre at f.eks. bruer kollapser under påvirkning av vindkast. 52

Symbolsk derivasjon Info om derivasjon - Def / Numerisk / Symbolsk y = 0.25x2 Numerisk derivasjon Symbolsk derivasjon y’ = 0.5x y = xcosx y’ = cosx - xsinx Derivasjon omhandler endringsstudier av en funksjon. Slike endringer studeres vha stigningstallet til tangenter til funksjonsgrafen. For en gitt funksjon er det av interesse å bestemme den deriverte funksjonen.

Symbolsk derivasjon Noen enkle derivasjonseksempler y = x2 y’ = 0 y = 4 y’ = 0 y = c y’ = 0 y = x y’ = 1 y = x2 y’ = 2x y = x3 y’ = 3x2 y = xn y’ = nxn-1 y = sin(x) y’ = cos(x) y = cos(x) y’ = -sin(x) y = ex y’ = ex y = c y’ = 2x y = x n y’ = 0 y’ = nxn-1 y = e x y = sinx y’ = ex y’ = cosx

Symbolsk derivasjon Avansert derivasjonseksempel

Symbolsk derivasjon Algoritme - Gjennomgang av derivasjonseksempel y = x2sin4x y = x2sin4x y’ = 2xsin4x + x2cos4x4 = 2xsin4x + 4x2cos4x y’ = 2xsin4x + 4x2cos4x

Symbolsk derivasjon Aritmetisk tre - binTree x ^ 2 * sin(4*x) x 2 ^ 4 x * sin * Omgjøring fra infix til postfix binTree y = x2sin4x * x ^ 2 * sin ( 4 * x ) * sin ^ sin ^ * ( ( x ^ 2 ) * ( sin ( 4 * x ) ) ) x 2 * ( ( x 2 ^ ) ( ( 4 x * ) sin ) * ) 4 x x 2 ^ 4 x * sin *

Symbolsk derivasjon Strategi Operator * * op Operand Operand 2 x x2 sinx op1 op2 u = 2 du = 0 v = x dv = 1 u = x2 du = 2x v = sinx dv = cosx u = op1 du = op1’ v = op2 dv = op2’ y = 2x y’ = duv + udv = 0x + 21 = 2 y = x2sinx y’ = duv + udv = 2xsinx + x2cosx y = u op v y’ = (u op v)’ For hvert subtre med høyde > 0: Roten er en operator, de to subtrærne er operander. Bestem venstre og høyre subtre samt deres deriverte.

Symbolsk derivasjon Funksjoner - Oversikt differentiateStack get_operand get_op_sum get_op_diff dSwitch get_op_prod get_differentiation get_op_div get_op_sin get_op_cos ...

Symbolsk derivasjon differentiateStack

Symbolsk derivasjon get_operand

Symbolsk derivasjon get_differentiation

Symbolsk derivasjon dSwitch

Symbolsk derivasjon get_op_...

Symbolsk derivasjon get_op_pot

Symbolsk derivasjon Derivasjon - Venstre subtre x ^ 2 * sin(4*x) y = x2sin4x x 2 ^ 4 x * sin * dS (*) get_op (^) get_op (x) op = * u = du = v = dv = out = x2 x dS (^) dS (x) get_diff (x) op = ^ u = du = v = dv = out = op = x … out = 1 1 2x get_op (2) 2 dSwitch (^,x,1,2,0) dS (2) get_diff (2) 2x op = 2 … out = get_op_pot (x,1,2,0) 2x

Symbolsk derivasjon Derivasjon - Høyre / Venstre subtre x ^ 2 * sin(4*x) y = x2sin4x x 2 ^ 4 x * sin * dS (*) get_op (sin) get_op () op = * u = du = v = dv = out = x2 sin(4x) 2x dS (sin) dS () get_diff () op = sin u = du = v = dv = out = op = … out =

Symbolsk derivasjon Derivasjon - Høyre / Høyre subtre x ^ 2 * sin(4*x) y = x2sin4x x 2 ^ 4 x * sin * dS (sin) get_op (*) get_op (4) op = sin u = du = v = dv = out = 4x 4 dS (*) dS (4) get_diff (4) op = * u = du = v = dv = out = op = 4 … out = 4 get_op (x) x dSwitch (*,4,0,x,1) dS (x) get_diff (x) 4 op = x … out = 1 get_op_prod (4,0,x,1) 1 4

Symbolsk derivasjon Derivasjon - Høyre subtre x ^ 2 * sin(4*x) y = x2sin4x x 2 ^ 4 x * sin * dS (sin) op = sin u = du = v = 4x dv = 4 out = 4cos(4x) dSwitch (sin, , ,4x,4) 4cos(4x) get_op_sin ( , ,4x,4) 4xcos(4x)

Symbolsk derivasjon Derivasjon - Total x ^ 2 * sin(4*x) y = x2sin4x x 2 ^ 4 x * sin * dS (*) op = * u = x2 du = 2x v = sin(4x) dv = 4cos(4x) out = 2xsin(4x) + 4x2cos(4x) 2xsin(4x) + 4x2cos(4x) dSwitch (*,x2,2x,sin(4x),4cos(4x)) 2xsin(4x) + 4x2cos(4x) get_op_prod (x2, 2x,sin(4x),4cos(4x)) 2xsin(4x) + 4x2cos(4x)

Lenket liste implementering av binært tre ( a - b ) + c * ( e / f ) - info Data-informasjon - left Peker til venstre barn - right Peker til høyre barn Ulemper: - Plass-sløsing ved bruk av mange null-pekere. - Vanskelig å finne far til en gitt node. - Implementerings-metoden er relativt komplisert i språk som ikke benytter dynamisk memory-allok. De to første punktene kan utbedres vha tredde trær.

Preorder traversal ( a - b ) + c * ( e / f ) Step Stakk Output 1 5 + 2 1 - 5 +- 3 1 - 5 +-a 4 5 +-ab 5 9 +-ab* 6 9 +-ab*c 7 7 +-ab*c/ 8 7 +-ab*c/e 9 +-ab*c/ef Preorden gjennomløping av et tre vha en stakk hvor evnt peker til høyre barn plasseres.

Preorder traversal Algoritme - Bruk av stakk ( a - b ) + c * ( e / f ) Preorder traversal Algoritme - Bruk av stakk preorderTraversal (rot,info,left,right,stakk) /* Rutinen gjennomløper et binært tre vha preorder traversal */ slutt := 0 ref := rot IF ref = slutt THEN // tomt tre tom := true ELSE // ikke-tomt tre tom := false push(stakk,slutt) // initier stakk WHILE ref != slutt // gjennomløping prosess(info[ref]) // prosess for hvert element IF right[ref] != slutt THEN // finnes høyre-barn? push(stakk,right[ref]) // lagre peker til høyre barn ENDIF ref := left[ref] // søk gjennom venstre subtre IF ref = slutt THEN // ikke flere venstre subtre pop(stakk,ref) ENDWHILE

Preorder traversal Rekursjon - Bruk av tabeller preorderTraversal (rot) /* Rutinen gjennomløper et binært tre */ /* vha preorder traversal */ /* Rekursjon benyttes. */ /* rot : Peker til treets rot */ IF rot != slutt THEN prosess(info[rot]) preorderTraversal(left[rot]) preorderTraversal(right[rot]) ENDIF

Preorder traversal Rekursjon - Dynamiske elementer preorderTraversal (rot) /* Rutinen gjennomløper et binært tre */ /* vha preorder traversal */ /* Rekursjon benyttes. */ /* rot : Peker til treets rot */ IF rot != null THEN prosess(rot.info) preorderTraversal(rot.left) preorderTraversal(rot.right) ENDIF

Preorder – Inorder – Postorder traversal IF rot != null THEN prosess(rot.info) preorderTraversal(rot.left) preorderTraversal(rot.right) ENDIF Inorder IF rot != null THEN inorderTraversal(rot.left) prosess(rot.info) inorderTraversal(rot.right) ENDIF Postorder IF rot != null THEN postorderTraversal(rot.left) postorderTraversal(rot.right) prosess(rot.info) ENDIF

Sortering vha binært tre Et binært tre sies å være sortert (i stigende rekkefølge) når følgende er oppfylt: Til enhver node med innhold N vil: - venstre subtre kun inneholde elementer som er mindre enn N - høyre subtre kun inneholde elementer som er større enn eller lik N Dette medfører at i et sortert binært tre vil inorden traversering gi elementene i sortert rekkefølge.

Sortering vha binært tre 19 - 5 - 10 - 7 - 25 - 8 - 15 - 90 - 12 - 2 1. Første tall (her 19) plasseres i treets rot. 2. Neste tall 5 leses. 3. Siden 5 er mindre enn 19, plasseres 5 som venstre barn til 19. 4. Tallet 10 leses. 5. 10 er mindre enn 19, derfor går vi til venstre for 19. 10 er større enn 5, derfor plasseres 10 som høyre barn til 5. ...

Innsetting i sortert binært tre Innsetting av et element med info = N i et sortert binær tre gjøres ved følgende: - Sammenlign N med roten. - Hvis N < roten, søk videre i venstre subtre. - Hvis N >= roten, søk videre i høyre subtre. Innsetting av N = 14 14 < 19 gå til venstre 14 > 5 gå til høyre 14 > 10 gå til høyre 14 < 15 gå til venstre 14 > 12 gå til høyre Resultat: N = 14 settes inn som høyre barn til 12

Innsetting i et sortert binært tre Algoritme Innsett (info,left,right,led,post,rot,full) NULL := 0 IF Led = NULL THEN // Treet er fullt Full := True ELSE // Ledig plass i treet Full := False Ny := Led // Plasser ny post Led := Left[ny] // Ajourfør ledig-listen Info[Ny] := Post // Innsett data i ny post Left[Ny] := NULL Right[ny]:= NULL IF Rot = NULL THEN // Opprinnelig tomt tre Rot := Ny ELSE // Innsetting i ikke-tomt tre Peker := Rot WHILE Peker <> NULL DO // Søk nedover i treet Forrige := Peker IF Post < Info[Peker] THEN // Til venstre Peker := Left[Peker] ELSE // Til høyre Peker := Right[Peker] ENDIF ENDWHILE IF Post < Info[Forrige] THEN // Pekere til ny post Left[Forrige] := Ny ELSE Right[Forrige] := Ny

Slettting i binært tre Stine skal fjernes. Inorden gjennomløping av det binære treet gir elementene i sortert rekkefølge: Grete, Kari, Kjell, Lars, Martin, Nils,Ola, Per, Renate, Rolf, Stine, Trine, Truls, Åse. Stine skal fjernes. Dette kan løses på to måter: - Erstatt Stine med største element i venstre subtre hvor Stine er rot, dvs Rolf. - Erstatt Stine med minste element i høyre subtre hvor Stine er rot, dvs Trine.

Sletting i binært tre Stine skal fjernes. Erstatt Stine med største element i venstre subtre hvor Stine er rot, dvs Rolf.

Sletting i binært tre 1. Noden som skal slettes har ingen barn. 2. Noden som skal slettes har et høyre-barn, men ikke et venstre-barn. 3. Noden som skal slettes har et venstre-barn.

Sletting i et sortert binært tre - Algoritme Case 1: Noden som skal slettes har ingen barn sletting_1 (info,left,right,spek,pPek,rot,led) null := 0 IF ppek = null THEN // Fjerning av rot rot := null ELSE // Forelder finnes IF sPek = Left[pPek] THEN left[pPek] := null ELSE right[pPek] := null ENDIF left[sPek] := led // Ledigliste led := sPek pPek sPek

Sletting i et sortert binært tre - Algoritme Case 2: Noden som skal slettes har et høyre-barn, men ikke et venstre-barn sletting_2 (info,left,right,spek,pPek,rot,led) null := 0 IF ppek = null THEN // Fjerning av rot rot := right[sPek] ELSE // Forelder finnes IF sPek = Left[pPek] THEN left[pPek] := right[sPek] ELSE right[pPek] := right[sPek] ENDIF left[sPek] := led // Ledigliste led := sPek pPek sPek Case 1 er et spesialtilfelle av Case 2

Sletting i et sortert binært tre - Algoritme Case 3 Sletting i et sortert binært tre - Algoritme Case 3.1: Noden som skal slettes har et venstre-barn. Venstre-barn til noden som skal slettes har ikke høyre-barn. sletting_3_1 (info,left,right,spek,pPek,rot,led) null := 0 peker := left[sPek] // erst. slettet e. IF ppek = NULL THEN // Fjerning av rot rot := peker ELSE // Forelder finnes IF left[pPek] = sPek THEN left[pPek] := peker ELSE right[pPek] := peker ENDIF right[peker] := right[sPek] // Flyttet element left[sPek] := led // Ledigliste led := sPek pPek sPek

Sletting i et sortert binært tre - Algoritme Case 3 Sletting i et sortert binært tre - Algoritme Case 3.2: Noden som skal slettes har et venstre-barn. Venstre-barn til noden som skal slettes har høyre-barn. sletting_3_2 (info,left,right,spek,pPek,rot,led) null := 0 peker := left[sPek] forrige := peker WHILE right[peker] != null peker := right[peker] ENDWHILE IF ppek = NULL THEN // Fjerning av rot rot := peker ELSE // Forelder finnes IF left[pPek] = sPek THEN left[pPek] := peker ELSE right[pPek] := peker ENDIF right[peker] := right[sPek] right[forrige] := left[peker] left[peker] := left[sPek] left[sPek] := led // Ledigliste led := sPek pPek sPek

Ulike strukturer av binært tre I et tre (her binært tre) kan det av og til være ønskelig med ekstra pekere bl.a. for å lette gjennomløping av et slikt tre.

Tredde trær I såkalte tredde trær benyttes såkalte Tpekere (opprinnelige null-pekere fra løv-noder) til å peke oppover i treet igjen, dette bl.a. for å lette gjennomløping av et slikt tre. Tpekere settes negative. En Tpeker som erstatter en leftPeker, peker til foregående node og en Tpeker som erstatter en rightPeker, peker til neste node (begge ved inorden gjennomløping. Ytterste venstre og høyre Tpeker peker tilbake til roten.

Tredde trær - Tomt tre med dummynode Et tomt tredd tre med dummynode. Det er hensiktsmessig å la høyre Tpeker være en ordinær peker, dvs høyre Tpeker er positiv. Head

Tredde trær - Lenket liste vha array

Tredde trær treddInorder - Algoritme treddInorder (info,left,right,rot,tom) peker := rot IF Abs(left[peker]) = rot THEN // tomt tre tom := true ELSE // Ikke-tomt tre tom := false REPEAT IF right[peker] < 0 THEN // Tpeker peker := abs(right[peker]) ELSE // Ordinær peker peker := right[peker] WHILE left[peker] > 0 DO // Søk nedover til venstre peker := left[peker] ENDWHILE ENDIF IF peker <> rot THEN // Reell node prosess(info[peker]) UNTIL peker = rot // Hele treet gjennomløpt

Balanserte trær For å minimalisere gjennomsnittlig søke-lengde etter en gitt node i et tre, er det viktig at venstre og høyre subtre til en node er av tilnærmet samme lengde. For å kontrollere ulikheter i lengden av venstre/høyre subtre, innføres for hver node en såkalt balansefaktor (BF). BF = lengden av venstre subtre - lengden av høyre subtre Et tre sies å være balansert hvis alle noder har en balansefaktor BF = -1,0,1

Balansefaktor - Eksempel 5

AVL-rotasjon Ved innsetting gjøres følgende: 1. La nytt element gjennomløpe greinene inntil innsettingspunkt er funnet. Samtidig merkes av siste node hvor opprinnelig balansefaktor er +1 eller -1. Denne noden kalles for PIVOT-noden. Innsett nytt element på korrekt plass. 2. Korriger balansefaktoren for PIVOT-noden og samtlige noder i det subtreet som har PIVOT-noden som rot. Det kan vises at ingen andre noder i treet får sin balansefaktor endret ved AVL-rotasjoner. 3. Hvis absoluttverdien av balansefaktoren for PIVOT-noden ble endret fra 1 til 2, så skal subtreet hvor PIVOT-noden er rot gjennomgå en AVL-rotasjon. Dette gjøres ved å endre pekere, men på en slik måte at treet’s ordnings-rekkefølge blir uendret.

Case 1: Innsetting i venstre subtre til venstre barn til Pivot-node [1/2]

AVL_Left_Left (left, right, bf, pivot) Case 1: Innsetting i venstre subtre til venstre barn til Pivot-node [2/2] lPek (1) 4 AVL_Left_Left (left, right, bf, pivot) /* AVL_Left_Left-rotasjon */ /* left Tabell med venstre-peker */ /* right Tabell med høyre-peker */ /* bf Tabell med balansefaktor */ /* pivot Peker til pivot-node */ lPek := left[pivot] // 1 rPek := right[lPek] // 2 right[lPek] := pivot // 3 left[pivot := rPek // 4 pivot := lPek // 5 bf[pivot] := 0 // 6 bf[right[pivot]] := 0 // 7 3 pivot (5) rPek (2)

Case 2: Innsetting i høyre subtre til høyre barn til Pivot-node

Case 3.1: Innsetting i høyre subtre til venstre barn til Pivot-node

Case 3.2: Innsetting i venstre subtre til høyre barn til venstre barn til Pivot-node

Case 3.3: Innsetting i høyre subtre til høyre barn til venstre barn til Pivot-node

Case 4: Innsetting i venstre subtre til høyre barn til Pivot-node Algoritmene til Case 4 blir analoge med algoritmene til Case 3.

Generell tre I et binært tre har hver node maksimalt to barn. I et generelt tre har hver node et vilkårlig antall barn. Ethvert generelt tre kan implementeres som et binært tre.

Variabelt antall pekere til barn Generelt tre hvor hver node har et variabelt antall pekere til barna.

To pekere: Første venstre barn Første høyre søsken (1/2) Binær implementering av generelle tre. En nodes to pekere benyttes til følgende: Venstre peker : Peker til nodens første venstre barn. Høyre peker : Peker til nodens første høyre søsken.

To pekere: Første venstre barn Første høyre søsken (2/2)

Ternary tre implementering (1/2) Ternary tre implementering av generelle tre. En nodes tre pekere benyttes til følgende: 1. LSøsken : Peker til nodens første venstre søsken. 2. RSøsken : Peker til nodens første høyre søsken. 3. LBarn : Peker til nodens første venstre barn.

Ternary tre implementering (2/2)

Hierarkisk datastruktur - Bil Tre-struktur / Hierarkisk struktur benyttes ofte der hvor det er aktuelt å få svar på spørsmål av typen: - Gitt et objekt, hvilke komponenter består objektet av ? - Gitt et objekt, hvilket større objekt er dette en del av ?

Hierarkisk datastruktur - Trekant (1/4)

Hierarkisk datastruktur - Trekant (2/4) Ulemper med denne strukturen: - Vi må gå gjennom kantene for å finne hvilke hjørner trekanten består av. - Strukturen gir inntrykk av at trekanten består av til sammen 6 hjørner. Imidlertid vil en kant dele sine endepunkter med andre kanter. - Uten bakoverpekere vil vi til en gitt kant (eller hjørne) ikke kunne finne ut hvilken trekant denne kanten (eller hjørnet) tilhører.

Hierarkisk datastruktur - Trekant (3/4) - Vi tar utgangs-punkt i at en trekant består av 3 kanter og 3 hjørner. - Videre ønsker vi mulighet for raskt å kunne scanne igjennom kantene/hjørnene til en gitt trekant. - Uansett hvor vi kommer inn på kant/hjørne skal vi raskt kunne scanne igjennom de øvrige kantene/hjørnene. - For gitt kant/hjørne skal vi raskt kunne finne ut hvilken trekant denne tilhører. Siden det til hver kant finnes to endepunkter, kan vi bestemme foreldre-elementet til en gitt kant ved å gå gjennom ett av endepunktene. Dette vil spare lagerplass. - For gitt kant skal vi raskt kunne bestemme denne kantens endepunkter. - En trekant kan vi tenke oss som en del av et større geometrisk objekt bestående av flere elementer. For hver trekant ønsker vi derfor en peker til neste element.

Hierarkisk datastruktur - Trekant (4/4) - Type - Peker til første kant - Peker til første hjørne - Peker til neste element Hjørne: - XKoordinat - YKoordinat - Peker til neste hjørne - Peker til foreldre Kant: - Peker til endepunt 1 - Peker til endepunt 2 - Peker til neste kant

Hierarkisk datastruktur - Multiple trekanter - Type - Peker til første kant - Peker til første hjørne - Peker til neste element Hjørne: - XKoordinat - YKoordinat - Peker til neste hjørne - Peker til foreldre Kant: - Peker til endepunt 1 - Peker til endepunt 2 - Peker til neste kant - Peker til tilsluttet kant - Peker til nabo-trekant

Hierarkisk datastruktur - Grafisk system Trekant: - Type - Peker til første kant - Peker til første hjørne - Peker til neste element Hjørne: - XKoordinat - YKoordinat - Peker til neste hjørne - Peker til foreldre Kant: - Peker til endepunt 1 - Peker til endepunt 2 - Peker til neste kant - Peker til tilsluttet kant - Peker til nabo-trekant

Implementering av binært tre vha C++ En klasse Tnode utgjør nodene i treet. Hver Tnode har tre pekere: - left : Peker til venstre barn - right : Peker til høyre barn - ePtr : Peker til ’virkelig’ element En klasse Tree administrerer treet. Tree inneholder tre attributter: - root : Peker til roten i treet - tNodePtr : Peker til gjeldende node - count : Antall noder En klasse TreeIterator scanner treet.

I_SearchableContainer Klassehierarki - Tre I_Comparable A_Object I_Container A_Container I_SearchableContainer I_Tree A_Tree GeneralTree Test BinaryTree Test I_Tree Interface for tre I_SearchTree Interface for søketre I_PreInPostVisitor Interface for PreOrden, InOrden og PostOrden gjennomløping av et tre A_Tree Abstrakt klasse for tre A_PreInPostVisitor Abstrakt klasse for PreOrden, InOrden og PostOrden gjennomløping av et tre GeneralTree Klasse for generelt tre BinaryTree Klasse for binærtre BinarySearchTree Klasse for binært søketre PreOrder Klasse for pre-orden gjennomløping av et tre InOrder Klasse for in-orden gjennomløping av et tre (gjelder kun for binært tre) PostOrder Klasse for post-orden gjennomløping av et tre I_SearchTree BinarySearchTree Test I_PreInPostVisitor A_PreInPostVisitor PreOrder InOrder PostOrder

A Interface I_Tree B D C E G H F Interface I_Tree som gir grensesnittet for datastrukturen tre: I_Tree Interface for tre. getRoot Returnerer roten getSubtree Returnerer subtre nr i getDegree Returnerer graden til roten getHeight Returnerer høyden til treet (= høyden til roten) isLeaf Returnerer true hvis roten er et løv depthFirstTraversal Dybde først gjennomløp breadthFirstTraversal Bredde først gjennomløp

A depthFirstTraversal B D C E G H depthFirstTraversal omfatter de tre spesialtilfellene: - PreOrder - InOrder (kun for binære trær) - PostOrder For å kunne håndtere disse tre spesialtilfellene, benytter depthFirstTraversal parametertypen I_PreInPostVisitor. For å kunne sende en I_Visitor til depthFirstTraversal lages en såkalt adapter (konverterer et interface nødvendig for en klasse over til et annet interface nødvendig for en annen klasse). Vi benytter 3 slike adaptere: Klassene PreOrder, InOrder og PostOrder som alle implementerer I_PreInPostVisitor. I_Visitor v = new …Visitor( ); I_Tree t = new …Tre( ); … t.depthFirstTraversal (new PreOrder(v)); F depthFirstTraversal Dybde først gjennomløp. depthFirstTraversal omfatter tre spesialtilfeller: - PreOrder Besøker roten i et subtre før barna til denne roten - InOrder Besøker først venstre subtre, så roten og til slutt høyre subtre (gjelder kun for binært tre) - PostOrder Besøker alle barna til roten i et subtre før roten besøkes To ulike strategier kan benyttes ved implementering av dybde først gjennomløp: - Spesialprogramere hver for seg de tre nevnte spesialtilfellene. - Benytte en fellesrutine for alle spesialtilfellene vha såkalte adaptere. En slik adapter kan konvertere et interface nødvendig for en klasse over til et interface nødvendig for en annen klasse. Vi benytter tre slike adaptere: PreOrder, InOrder og PostOrder som alle implementerer I_PreInPostVisitor. depthFirstTraversal benytter nå en parameter av typen I_PreInPostVisitor. Vi konstruerer først et tre I_Tree t = new …Tre( ) og en visitor I_Visitor v = new …Visitor( ) Hvis vi nå ønsker å gjennomløpe treet t i preorden rekkefølge med denne visitoren v, setter vi følgende: t.depthFirstTraversal ( new PreOrden(v));

Interface I_PreInPostVisitor B D C E G H F Interface I_PreInPostVisitor for dybde-først gjennomløp av et tre: I_PreInPostVisitor Interface beregnet på klassene PreOrder, InOrder og PostOrder. preVisit Visit-metode som skal eksekveres ved preorden gjennomløp inVisit Visit-metode som skal eksekveres ved inorden gjennomløp postVisit Visit-metode som skal eksekveres ved postorden gjennomløp isDone Returnerer true hvis gjennomløpingen skal avsluttes

Abstract class A_PreInPostVisitor A_PreInPostVisitor Abstrakt klasse som implementerer I_PreInPostVisitor Denne abstrakte klassen implementerer de tre metodene preVisit, inVisit og postVisit med tom body-del. Metoden isDone har default returverdi false. Her er benyttet adapter-tankegang ved at arvede klasser kun skal benytte en av metodene preVisit, inVisit og postVisit, samt at isDone i svært mange sammenhenger kun skal returnere false fordi en visitor ofte gjennomløper hele datastrukturen.

class PreOrder PreOrder Ved en deklarering av en forekomst av PreOrder (eller klasser arvet fra PreOrder) følger en parameter visitor av typen I_Visitor med. Klassen PreOrder implementerer metoden preVisit som igjen kaller opp metoden visit i visitor-forekomsten.

class InOrder InOrder Ved en deklarering av en forekomst av InOrder (eller klasser arvet fra InOrder) følger en parameter visitor av typen I_Visitor med. Klassen InOrder implementerer metoden inVisit som igjen kaller opp metoden visit i visitor-forekomsten.

class PostOrder PostOrder Ved en deklarering av en forekomst av PostOrder (eller klasser arvet fra PostOrder) følger en parameter visitor av typen I_Visitor med. Klassen PostOrder implementerer metoden postVisit som igjen kaller opp metoden visit i visitor-forekomsten.

abstract class A_Tree depthFirstTraversal G H F A_Tree Abstrakt klasse for datastrukturen tre. depthFirstTraversal Dybe først gjennomløp. En parameter visitor av typen I_PreInPostVisitor følger med. Denne parameteren er en forekomst av en klasse arvet enten fra PreOrder eller PostOrder, avhengig av hvorvidt gjennomløpingen skal være PreOrden eller PostOrden. Rutinen er rekursiv. For PreOrden gjennomløp vil postVisit-metoden være tom. For PostOrden gjennomløp vil preVisit-metoden være tom. inVisit-metoden er ikke aktuell for annet enn binært tre.

abstract class A_Tree breadthFirstTraversal G H F breadthFirstTraversal Bredde først gjennomløp. En parameter visitor av typen I_Visitor følger med. Datastrukturen kø benyttes som hjelpemiddel.

abstract class A_Tree accept D C E G H F accept Gjennomløping med en visitor av typen (I_Visitor). Default gjennomløping er preorden dybde først gjennomløp.

abstract class A_Tree getEnumeration D C E G H F En parameter visitor av typen I_PreInPostVisitor følger med. getEnumeration Returnerer en nummerering for gjennomløping av et tre (se neste side).

abstract class A_Tree TreeEnumeration D C E G H F TreeEnumeration Indre klasse i klassen A_Tree. Default nummerering er preorden dybde først gjennomløp. I motsetning til rutinen depthFirstTraversal hvor vi kunne programmere rekursivt, må vi her benytte en stakk som hjelpemiddel.

abstract class A_Tree TreeEnumeration hasMoreElements - nextElement D C E G H F hasMoreElements Flere elementer finnes hvis stakken ikke er tom. nextElement Finner neste element ved å poppe fra stakken. For neste element, pushes denne nodens subtrær til stakken.

A abstract class A_Tree getRoot – getSubtree getDegree- getHeight - isLeaf B D C E G H F Kun default-verdier returneres fra metodene getRoot, getSubtree, getDegree, getHeight og isLeaf.

Generelt tre Benytter en liste over alle barna til en gitt node A B D C E G H F Benytter en liste over alle barna til en gitt node A B D Den abstrakte klassen A_Tree beskrevet på de foregående sidene er tiltenkt alle typer trær, enten de er binære trær (maks to barn til hver node) eller de er mer generelle trær (vilkårlig antall barn til hver node). I den videre behandlingen skiller vi skarpt mellom generelle trær og binære trær i stedet for å betrakte binære trær som spesialtilfelle av generelle trær. Dette skyldes at disse to typer trær har mange separate spesialiteter. Vi ser først på generelle trær (vilkårlig antall barn til hver node). For hver node lar vi en liste representere denne nodens barn. Hver liste lar vi være forekomst av DList. C E G H F

Generelt tre constructor A Generelt tre constructor B D C E G H F GeneralTree Klasse for generelle trær (hver node kan ha et vilkårlig antall barn). root Treets rot (for et subtre: Subtreets rot) degree Rotens grad (antall subtrær til roten) list Liste som representerer rotens subtrær

Generelt tre getRoot - getDegree - getSubtree A Generelt tre getRoot - getDegree - getSubtree B D C E G H F getRoot Returnerer treets (subtreets) rot getDegree Returnerer graden til treets (subtreets) rot getSubtree ( int i) Returnerer subtre nr i til treets (subtreets) rot

Generelt tre attachSubtree - detachSubtree F attachSubtree (General tree) Legger til et nytt subtre til treets (subtreets) rot detachSubtree (General tree) Fjerner et gitt subtre fra treets (subtreets) rot

Generelt tre isLeaf - isEmpty - removeAll B D C E G H F isLeaf ( ) Returnerer true hvis treets (subtreets) rot er et løv isEmpty ( ) Returnerer true hvis treet (subtreet) er tomt removeAll ( ) Fjerner alle nodene i treet (subtreet)

Test Generelt tre (1/2) A B C D Test-program for klassen GeneralTree. Tilordner 4 forekomster (objA, objB, objC og objD) av typen Za og Zb med innhold henholdsvis 5, 7-9, 2-4,3-6. Plasserer disse 4 objektene i hvert sitt tre (hvert tre vil foreløpig bestå av kun roten, kaller disse trærne videre for A, B, C og D). treeA.attachSubtree (treeB) Legger til B som et subtre til A treeA.attachSubtree (treeC) Legger til C som et subtre til A treeB.attachSubtree (treeD) Legger til D som et subtre til B

Test Generelt tre (2/2) A B C D Test-program for klassen GeneralTree (forts.). Skriver ut innholdet fra samtlige noder i treet hvor A er rot. Skriver ut innholdet fra roten i det subtreet hvor B er rot ( ((Za)treeB.getRoot( )).print( ) ) Tilordner en forekomst visitorPrint av typen I_Visitor. Bredde først gjennomløp med utskrift av hver node vha visitorPrint. Tilordner en forekomst postVisitorPrint av typen I_PreInPostVisitor. Postorden dybde først gjennomløp med utskrift av hver node vha postVisitorPrint. Tilordner en nummerering enumTree og benytter denne til default preorden dybde først gjennomløp med utskrift av hver node.

Binært tre Bruk av eksterne (tomme) noder C E G F A B D C Ø E G Vi skal nå se litt nærmere på binært tre. Vi skal definere en egen klasse BinaryTree helt uavhengig av klassen GeneralTree fordi det finnes mange fundamentale ulikheter innen disse to separate tre-strukturene. Et binært tre kan vi definere som et tre hvor hver node har maksimalt to barn. Her skal vi definere et binært tre som et tre hvor hver node har eksakt to barn, men for noen av nodene vil det ene eller begge barna være en tom node (tom node merket med rød farge i figuren ovenfor). Den sistnevnte implementeringen har visse fordeler programmeringsmessig. Nodene merket med rød farge ovenfor (tom node, tomt subtre, dvs roten er tom) kalles for eksterne noder, de øvrige nodene (merket med grønn farge) kalles interne noder. Ø Ø Ø F Ø Ø Ø Ø

Binært tre constructors A Binært tre constructors B D C E G F BinaryTree Klasse for binært tre. root Roten i det binære treet (eller det binære subtreet), null for ekstern node left Venstre barn (subtre) right Høyre barn (subtre) BinaryTree (Object root) Konstruktør. Tilordner et nytt binært tre (binært subtre) med rot root og to eksterne noder som barn. BinaryTree (Object root, BinaryTree left, BinaryTree right) Tilordner et nytt binært tre (binært subtre) med rot root, venstre subtre left og høyre subtre right. left og right må her aldri være null hvis root er forskjellig fra null fordi enhver node skal ha eksakt to barn (ikke-tomme eller tomme).

Binært tre getRoot - getLeft - getRight A Binært tre getRoot - getLeft - getRight B D C E G F getRoot ( ) Returnerer det binære treets (subtreets) rot getLeft ( ) Returnerer det binære treets (subtreets) venstre barn (venstre subtre) getRight ( ) Returnerer det binære treets (subtreets) høyre barn (høyre subtre)

Binært tre attachLeft - attachRight D C E G F attachSubtree (BinaryTree tree) Legger til et nytt binært subtre til det binære treets (subtreets) rot detachSubtree (BinaryTree tree) Fjerner et gitt binært subtre fra det binære treets (subtreets) rot

Binært tre isEmpty - isLeaf - removeAll D C E G F isEmpty ( ) Returnerer true hvis det binære treet (subtreet) er tomt isLeaf ( ) Returnerer true hvis det binære treets (subtreets) rot er et løv (har kun eksterne subtrær). removeAll ( ) Fjerner alle nodene i treet (subtreet)

Binært tre deptFirstTraversal C E G F depthFirstTraversal Dybe først gjennomløp. En parameter visitor av typen I_PreInPostVisitor følger med. Denne parameteren er en forekomst av en klasse arvet enten fra PreOrder, InOrder eller PostOrder, avhengig av hvorvidt gjennomløpingen skal være PreOrden, InOrden eller PostOrden. Rutinen er rekursiv. For PreOrden gjennomløp vil inVisit- og postVisit-metoden være tom. For InOrden gjennomløp vil preVisit- og postVisit-metoden være tom. For PostOrden gjennomløp vil preVisit- og inVisit-metoden være tom.

Binært tre breadthFirstTraversal C E G F breadthFirstTraversal Bredde først gjennomløp. En parameter visitor av typen I_Visitor følger med. Datastrukturen kø benyttes som hjelpemiddel.

Test Binært tre (1/2) A B C D Test-program for klassen BinaryTree. Tilordner 4 forekomster (objA, objB, objC og objD) av typen Za og Zb med innhold henholdsvis 5, 7-9, 2-4,3-6. Plasserer objC som roten i et nytt binært tre treeC. Plasserer objD som roten i et nytt binært tre treeD. Plasserer objB som roten i et nytt binært tre hvor treeD blir ventrebarn (ingen høyre barn, dvs en ektern node som høyre barn). Plasserer objA som roten i et nytt binært tre hvor treeB blir venstrebarn og treeC blir høyre barn.

Test Binært tre (2/2) A B C D Test-program for klassen BinaryTree (forts.). Skriver ut innholdet i det binære treets 4 (interne) noder. Tilordner en forekomst inVisitorPrint av typen I_PreInPostVisitor og benytter denne til InOrden gjennomløp ved dybde først gjennomløp med utskrift av samtlige (interne) noders innhold. Tilordner en forekomst postVisitorPrint av typen I_PreInPostVisitor og benytter denne til PostOrden gjennomløp ved dybde først gjennomløp med utskrift av samtlige (interne) noders innhold.

interface I_SearchTree B D C E G F I_SearchTree Interface med henblikk på søke/sorterings-muligheter i et tre. findMin Returnerer minste element (node) av typen I_Comparable i et tre. findMax Returnerer største element (node) av typen I_Comparable i et tre.

BinarySearchTree getLeftBST - getRightBST D C E G F BinarySearchTree Klasse for binært tre med søke-/sorterings-muligheter. getLeftBST Returnerer venstre subtre (av typen BinarySearchTree). getRightBST Returnerer høyre subtre (av typen BinarySearchTree).

BinarySearchTree find G F find Søker etter (og eventuelt returnerer) en node av typen I_Comparable med gitt innhold i et sortert binært søketre.

BinarySearchTree findMin - findMax G F findMin Søker etter og returnerer den minste noden i et sortert binært søketre. finMax Søker etter og returnerer den største noden i et sortert binært søketre.

BinarySearchTree insert - attachRoot - balance D C E G F insert (I_Comparable obj) Innsetter en node obj av typen I_Comparable i et sortert binært søketre. attachRoot (Object obj) Setter nytt innhold i det binære søketreets rot. Venstre og høyre barn blir eksterne noder. balance ( ) Balansering av det binære søketreet i så fall en innsetting lager ubalanse i treet. Er foreløpig ikke implementert.

BinarySearchTree remove D C E G F remove (I_Comparable obj) Fjerner node (av typen I_Comparable) med gitt innhold fra det binære søketreet.

BinarySearchTree isMember D C E G F isMember (I_Comparable object) Returnerer true hvis et gitt objekt er medlem (finnes) i det binære søketreet. Foreløpig ikke implementert.

Test BinarySearchTree D Test-program for klassen BinarySearchTree. Tilordner 4 forekomster (objA, objB, objC og objD) av typen W_Int med innhold henholdsvis 5, 7, 3, 2. Tilordner et nytt (foreløpig tomt) binært søketre bsTree. Setter objA inn sortert i det binære søketreet bsTree. Setter objB inn sortert i det binære søketreet bsTree. Setter objC inn sortert i det binære søketreet bsTree. Setter objD inn sortert i det binære søketreet bsTree. Skriver ut innholdet av alle treets noder. Tilordner forekomsten inVisitorPrint av typen I_PreInPostVisitor og benytter denne til inorden dybde først gjennomløp med utskrift av samtlige noder.

END End.