Kap 09 Tre

Kap 09 TreKap 09 TreKap 09 TreKap 09 Tre

Slektstre

Barn

Foreldre

Barne-barn

Far / Mor

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

Student-opplysninger

KK3EK3KK2EK2KK1EK1

KursAdresseNavn

K3K2K1Post-nrSted

GateVei

Etter-navn

For-navn

Person-nr

Fødsels-dato

Fødsels-nr

Student

Adresse

Post-nrSted

GateVei

Trestruktur med studentopplysninger(fødselsnr, navn, adresse, kurs, eksamener)

Subtre er en del av et treog er selv et tre

Filkataloger

K3 K4K3K2K1K2K1

BrukerFiler

KariNilsCPascal

ProgramFiler

FileDirectory

Filkataloger

Kompilering

a a a

b'b'a'a'IntegerInteger

ba

WriteWrite

ELSETHENBet

IFReadWriteReadWriteba

BEGINEND

Var

Testvoid 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;}

Kompilering av program ved programsplitting i en trestruktur

Tre - Definisjon

T = {R} U T1 U T2 U … U Tn

= {R, T1, T2, …, Tn}

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 rotog de resterende nodene er partisjonert i n >= 0 såkalte subtrærT1, T2, …, Tn hvor hver Ti selv er et tre.

Tre - Eksempler

T = {A}A

A

A

B

B D

C E G H

T = {A, {B}}

T = {A, {B, {C}}, {D, {E, {F}}, {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

A

B D

C E G H

F

Graden til A er 2Graden til B er 1Graden til C er 0Graden til D er 3

C, F, G og H er løv

B og D er barn til AC, E, G og H er barnebarn til AF er barn til E

A er foreldreelement til B og D

B og D er søskenE, G og H er søsken

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 <= kslik at den i-te noden vi er foreldreelement til den (i+1)-te noden vi+1.Lengden av veien P er k-1.

A

B D

C E G H

F

Veien P = {A, D, E, F} har lengde 3.

Veien P = {D,H} har lengde 1.

Veien P = {B} har lengde 0.

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 somden 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

A

B D

C E G H

F

Nivået til A er 0Nivået til B er 1Nivået til C er 2Nivået til F er 3

Høyden til A er 3Høyden til B er 1Høyden til C er 0Høyden til F er 0Høyden til G er 0Høyden til treet T er lik høyden til A, dvs 3

D er forgjenger (også ekte forgjenger) til ED er forgjenger (også ekte forgjenger) til FD er forgjenger til D

G er etterfølger (også ekte etterfølger) til AG er etterfølger til G

N-ary Tre - Definisjon

T = {R, T0, T1, …, TN-1}

hvor hver Ti er et N-ary tre

Et N-ary tre T er et tre hvor alle nodene har samme grad N.

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 - EksempelTertiær tre (N = 3)

T = {A,Ø,Ø,Ø}A

A

B T = {A,{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

A

B D

C E G H

F

N = 3Interne noder : n = 8Eksterne noder : e = (N-1)n+1 = (3-1)8+1 = 17


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 nodeog 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)

… …

1 k k+1

N-ary Tre - Teorem 9.2 - Eksempel

N = 3Høyde = 3Maksimalt 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 = 3Høyde = 3Maksimalt antall eksterne noder = Nh+1 = 33+1 = 34 = 81


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 tommesubtrær. Den ene noden er derfor et løv. Teoremet holder for h = 0siden 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

… …

1 k k+1


N = 3Høyde = 3Maksimalt 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

B C

D

A

B C

D=

Tre gjennomløping

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

A

B D

C E H

F

Tre gjennomløpingBredde først

Bredde først gjennomløp:Gjennomløping etter nivå: 0,1,2,...

A - B - D - C - E - G- H - FA

B D

C E H

F

G

Tre gjennomløpingDybde førstPreOrden

PreOrden gjennomløp:

1. Besøk roten2. PreOrden gjennomløp av subtrærne til roten

A - B - C - D - E - F - G- H

A

B D

C E H

F

G

Tre gjennomløpingDybde førstPreOrden (for binært tre)

PreOrden gjennomløp:

1. Besøk roten2. Gjennomløp venstre subtre3. Gjennomløp høyre subtre

A - B - C - D - E - F - H

A

B D

C E H

F

Tre gjennomløpingDybde førstInOrden (kun for binært tre)

InOrden gjennomløp:

1. Gjennomløp venstre subtre2. Besøk roten3. Gjennomløp høyre subtre

C - B - A - F - E - D - H

A

B D

C E H

F

Tre gjennomløpingDybde førstPostOrden

PostOrden gjennomløp:

1. PostOrden gjennomløp av subtrærne til roten 2. Besøk roten

C - B - F - E - G- H - D - A

A

B D

C E H

F

G

Tre gjennomløpingDybde førstPostOrden (for binært tre)

PostOrden gjennomløp:

1. Gjennomløp venstre subtre2. Gjennomløp høyre subtre3. Besøk roten

A

B D

C E HC - B - F - E - H - D - A

F

Tre gjennomløpingDybde førstOppsummering: Pre- / In- / Post-Orden (for binært tre)

PostOrden1. Venstre subtre2. Høyre subtre3. Roten

A

B D

C E H

C-B-F-E-H-D-A

F

InOrden1. Venstre subtre2. Roten3. Høyre subtre

PreOrden1. Roten2. Venstre subtre3. Høyre subtre

C-B-A-F-E-D-HA-B-C-D-E-F-H

1

2 3

2

1 3

3

1 2

Aritmetisk tre

fe

/c

*

ba

-

+

( a - b ) + c * ( e / f )

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 mellomde to operandene plassert som venstre og høyre subtre.

Operand Operand

Operator

Traversering av et binært treAritmetisk tre

fe

/c

*

ba

-

+

( a - b ) + c * ( e / f )

Inorder traversal :1. Gjennomløp venstre subtre2. Besøk roten3. Gjennomløp høyre subtre

Preorder traversal :1. Besøk roten2. Gjennomløp venstre subtre3. Gjennomløp høyre subtre

Postorder traversal :1. Gjennomløp venstre subtre2. Gjennomløp høyre subtre3. Besøk roten

( a - b ) + c * ( e / f )

+ - a b * c / e f

a b - c e f / * +

Aritmetisk treInOrden gjennomløp

fe

/c

*

ba

-

+

( a - b ) + c * ( e / f )

1. Skriv venstreparentes2. Gjennomløp venstre subtre3. Skriv roten4. Gjennomløp høyre subtre5. Skriv høyre parentes

(( a - b ) + (c * ( e / f )))

Lineær implementering av binært tre

2n+1

2n

n

1

HBarn

Node

VBarn

Rot

Vi kan representere et binært tre med høyde h vha en en-dimensjonal tabellmed 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 2nog høyre barn i lokasjon nr 2n+1.

1212

1222...222

rekke geometrisk 1

1

11

0210

1

hh

h

n

n k

kas

.....

24

22

21

2

1

0

fe

/c

*

ba

-

+

Lineær implementering av binært treAritmetisk tre

( a - b ) + c * ( e / f )

15

14

13

12

11

10

9

8

7

6

5

4

3

2

1

f

e

/

c

b

a

*

-

+

fe

/c

*

ba

-

+

Lineær implementering av binært treAritmetisk tre

( a - b ) + c * ( e / f )

15

14

13

12

11

10

9

8

7

6

5

4

3

2

1

f

e

/

c

b

a

*

-

+

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

En heap er en trestruktur med følgende undergrupper:

MaxHeap Generelt trehvor hver node har nøkkelverdi større enn eller lik nøkkelverdi til hvert av sine barn

MaxBinHeap Binært trehvor hver node har nøkkelverdistørre enn eller lik nøkkelverdi til hvert av sine barn

MinHeap Generelt trehvor hver node har nøkkelverdimindre enn eller lik nøkkelverdi til hvert av sine barn

MinBinHeap Binært trehvor hver node har nøkkelvedimindre enn eller lik nøkkelverdi til hvert av sine barn

8 5 73 2 6 1

2 5 37 9 4 8

8 5 7 43 2 6 1

2 5 3 96 8 4 7

Heap er hensiktsmessig bl.a. vedsortering, prioritetskø og komprimering

HeapBinary Heap

MaxBinHeapBinært trehvor hver node har nøkkelverdistørre enn eller lik nøkkelverdi til hvert av sine barn

MinBinHeapBinært trehvor hver node har nøkkelvedimindre enn eller lik nøkkelverdi til hvert av sine barn

Benytter lineær implementeringmed innsetting fra venstre, nivå for nivå

HeapInsert 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.

HeapInsert to a max binary heap - Algorithm

Insert_MaxBinHeap (a,n,x)

n := n + 1a[n] := xchild := nparent := n div 2WHILE parent >=1 DO

IF a[parent] < a[child] THENswap(a[parent],a[child])child := parentparent := parent div 2

ELSEparent := 0 // stop

ENDWHILE

HeapDelete 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.

HeapDelete from a max binary heap

Delete_MaxBinHeap (a,n,top,empty)

IF (n == 0) THENempty := true

ELSEempty := falsetop := a[1]a[1] := a[n]n := n – 1parent := 1child := 2WHILE (child <= n – 1) DO

IF (a[child] < a[child+1]) THENchild := child + 1

ENDIFIF (a[child] > a[parent]) THEN

swap(a[parent],a[child])parent := childchild := 2*child

ELSEchild := n // stop

ENDIFENDWHILE

ENDIF

HeapBuilding a max binary heap - Algorithm

Build_MaxBinHeap (a,n)

FOR i := 2 TO n DOInsert_MaxBinHeap(a,i-1,a[i])

ENDFOR

Gitt en array a[1..n]av elementeri vilkårlig rekkefølge.

Induksjon:1. a[1] er en heap2. Anta at a[1..k] er en heap3. Tilordning av a[1..k+1] til en heap

Benytt Insert_MaxBinHeaptil å innsette element nr k+1i heap a[1..k]

8 4

8 4 3

8 4 3 2

8 7 3 2 4

8 7 5 2 4 3

84

8 4 3

8 4 32

8 7 32 4

8 7 52 4 3

4 8 3 2 7 5

4 8 3 2 7 5

HeapRearrange a max binary heap - Algorithm

Rearrange_MaxBinHeap (a,n)

child := nparent := n div 2WHILE parent >=1 DO

IF a[parent] < a[child] THENswap(a[parent],a[child])child := parentparent := parent div 2

ELSEparent := 0 // stop

ENDWHILE

Insert_MaxBinHeap (a,n,x)n := n + 1a(n) := xRearrange_MaxBinHeap(a,n+1)

HeapHeapSort - 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

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

8 7 52 4 3

HeapHeapSort - Algorithm [2/2]

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 52 4 8

7 4 52 3 8

3 4 52 7 8

5 4 32 7 8

8 7 5 2 4 3 8 7 52 4 3

2 4 35 7 8

4 2 35 7 8

3 2 45 7 8

3 2 45 7 8

2 3 45 7 8

2 3 45 7 8

Data-komprimeringAscii-tabellSkrivbare tegn

Ascii-kode:0-255 28 = 2560-127 27 = 128 Skrivbare tegn

Binært Dec Tegn

010 0000 32 Space010 0001 33 !…010 1000 40 (100 0001 65 A100 0010 66 B100 0011 67 C…110 0001 97 a110 0010 98 b110 0011 99 c…

Data-komprimering

Binært Dec Tegn

010 0000 32 Space010 0001 33 !…010 1000 40 (100 0001 65 A100 0010 66 B100 0011 67 C…110 0001 97 a110 0010 98 b110 0011 99 c…

0 1

00 01 10 11

000 001 010 011 100 101 110 111

…

H a l l oHallo 10010000 1100001 1101100 1101100 110 1111

Data-komprimeringHuffman encoding - Prioritetskø vha Heap

Tegn Frekvens

A 5B 2C 3D 4E 10F 1

F 1

D 4 B 2

A 5 E 10 C 3

MinBinHeap

La vanlige tegn ha korte bitsekvenser, mens uvanlige tegn får lange bitsekvenser

Data-komprimeringHuffman encoding - Prioritetskø vha Heap

Huffman_Encodinginsert all elements into a minBinHeap H according to their frequenciesWHILE H is not empty DO

IF H contains only one X element THENmake X the root of binary tree T

ELSEpick 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 Hinsert a new element Z with children X an Y and f(Z) = f(X) + f(Y) into T

ENDIFENDWHILE

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 derivasjonDerivasjon benyttes til å beskrive prosessendringer

Newtons 2.lov

Radioaktivitet

Kvantefysikk

SHM

Varmetransport

Bølger

Elektrisk krets

)x(Fkx'cx''mx

ukt

u 2

zat

z 222

2

Typer av diff.lign.

ODE Ordinære Endringer mht en enkelt variabelPDE Partielle Endringer mht flere variabler

E

ti

h E)r(V

m2

h 22

vmdt

dF

dt

rdmF amF

2

2

kNdt

dN

Eidtdt

diLRi

Symbolsk derivasjonInfo om derivasjon - Def / Numerisk / SymbolskSymbolsk derivasjonInfo om derivasjon - Def / Numerisk / Symbolsk

y = xcosx y’ = cosx - xsinx

Derivasjon omhandler endringsstudier av en funksjon.Slike endringer studeres vha stigningstallettil tangenter til funksjonsgrafen.

For en gitt funksjon er det av interesseå bestemme den deriverte funksjonen.

Numeriskderivasjon

Symbolskderivasjon

y = 0.25x2

y’ = 0.5x

Symbolsk derivasjonNoen enkle derivasjonseksemplerSymbolsk derivasjonNoen enkle derivasjonseksempler

y = 4

y’ = 0

y = x2

y’ = 2x y = x n

y’ = cosx

y = sinx

y = e x

y’ = ex

y’ = nxn-1

y = cy’ = 0

y = 4 y’ = 0y = c y’ = 0

y = x y’ = 1y = x2 y’ = 2xy = x3 y’ = 3x2

y = xn y’ = nxn-1

y = sin(x) y’ = cos(x)y = cos(x) y’ = -sin(x)

y = ex y’ = ex

Symbolsk derivasjonAvansert derivasjonseksempelSymbolsk derivasjonAvansert derivasjonseksempel

Symbolsk derivasjonAlgoritme - Gjennomgang av derivasjonseksempelSymbolsk derivasjonAlgoritme - Gjennomgang av derivasjonseksempel

y = x2sin4x

y’ = 2xsin4x + x2cos4x4

= 2xsin4x + 4x2cos4x

y = x2sin4x

y’ = 2xsin4x + 4x2cos4x

Symbolsk derivasjonAritmetisk tre - binTreeSymbolsk derivasjonAritmetisk tre - binTree

y = x2sin4x

^

*

4

*x

sin

2

x

x ^ 2 * sin(4*x)

x 2 ^ 4 x * sin *

x ^ 2 * sin ( 4 * x )

( ( x ^ 2 ) * ( sin ( 4 * x ) ) )

( ( x 2 ^ ) ( ( 4 x * ) sin ) * )

x 2 ^ 4 x * sin *

*^

sin

*

Omgjøring frainfix til postfix

binTree

Symbolsk derivasjonStrategiSymbolsk derivasjonStrategi

*

2 x

u = 2du = 0

v = xdv = 1

y = 2xy’ = duv + udv

= 0x + 21= 2

* op

x2 sinx

u = x2

du = 2xv = sinxdv = cosx

y = x2sinxy’ = duv + udv

= 2xsinx + x2cosx

op1 op2

u = op1 du = op1’

v = op2 dv = op2’

y = u op vy’ = (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.

Operator

Operand Operand

Symbolsk derivasjonFunksjoner - OversiktSymbolsk derivasjonFunksjoner - Oversikt

differentiateStack

dSwitch

get_op_sum

get_differentiation

get_operand

get_op_diff

get_op_prod

get_op_div

get_op_sin

get_op_cos

...

Symbolsk derivasjondifferentiateStackSymbolsk derivasjondifferentiateStack

Symbolsk derivasjonget_operandSymbolsk derivasjonget_operand

Symbolsk derivasjonget_differentiationSymbolsk derivasjonget_differentiation

Symbolsk derivasjondSwitchSymbolsk derivasjondSwitch

Symbolsk derivasjonget_op_...Symbolsk derivasjonget_op_...

Symbolsk derivasjonget_op_potSymbolsk derivasjonget_op_pot

Symbolsk derivasjonDerivasjon - Venstre subtreSymbolsk derivasjonDerivasjon - Venstre subtre

y = x2sin4x

op = *u =du =v =dv =out =

dS (*)

x ^ 2 * sin(4*x)

x 2 ^ 4 x * sin *

get_op (^)

x2

dS (^)

get_op (x)

x

get_diff (x)

1

dSwitch (^,x,1,2,0)

get_op_pot (x,1,2,0)

2x

2x

2x

op = ^u =du =v =dv =out =

op = x…out =

dS (x)

1

get_op (2)

op = 2…out =

dS (2)

0

get_diff (2)

0

2

Symbolsk derivasjonDerivasjon - Høyre / Venstre subtreSymbolsk derivasjonDerivasjon - Høyre / Venstre subtre

y = x2sin4x


dS (*)

x ^ 2 * sin(4*x)

x 2 ^ 4 x * sin *

get_op (sin)

x2

dS (sin)

get_op ()

get_diff ()

op = sinu =du =v =dv =out =

op =…out =

dS ()2x

sin(4x)

Symbolsk derivasjonDerivasjon - Høyre / Høyre subtreSymbolsk derivasjonDerivasjon - Høyre / Høyre subtre

y = x2sin4x

op = sinu =du =v =dv =out =

dS (sin)

x ^ 2 * sin(4*x)

x 2 ^ 4 x * sin *

get_op (*)

dS (*)

get_op (4)

get_diff (4)

dSwitch (*,4,0,x,1)

get_op_prod (4,0,x,1)

4

4

4


op = 4…out =

dS (4)

get_op (x)

op = x…out =

dS (x)

1

get_diff (x)

1

x

4x 4

0

0

Symbolsk derivasjonDerivasjon - Høyre subtreSymbolsk derivasjonDerivasjon - Høyre subtre

y = x2sin4x

op = sinu =du =v = 4xdv = 4out =

dS (sin)

x ^ 2 * sin(4*x)

x 2 ^ 4 x * sin *

dSwitch (sin, , ,4x,4)

get_op_sin ( , ,4x,4)

4xcos(4x)

4cos(4x)

4cos(4x)

Symbolsk derivasjonDerivasjon - TotalSymbolsk derivasjonDerivasjon - Total

y = x2sin4x

op = *u = x2

du = 2xv = sin(4x)dv = 4cos(4x)out =

dS (*)

x ^ 2 * sin(4*x)

x 2 ^ 4 x * sin *

dSwitch (*,x2,2x,sin(4x),4cos(4x))

get_op_prod (x2, 2x,sin(4x),4cos(4x))

2xsin(4x) + 4x2cos(4x)




Lenket liste implementering av binært tre

*-

/cb

e f

a

+

- 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.

( a - b ) + c * ( e / f )

Preorder traversal

RightLeftInfo

9

8

7

6

5

4

3

2

1 0

0

5

0

9

1

0

0

7

0

0

6

0

8

4

0

0

2

b

e

+

a

*

-

f

c

/

( a - b ) + c * ( e / f )

*-

/cb

e f

a

+

1 5 +2 1 - 5 +-3 1 - 5 +-a4 5 +-ab5 9 +-ab*6 9 +-ab*c7 7 +-ab*c/8 7 +-ab*c/e9 +-ab*c/ef

Step Stakk Output

Preorden gjennomløping av et trevha en stakk hvor evnt peker til høyre barn plasseres.

Preorder traversalAlgoritme - Bruk av stakk

( a - b ) + c * ( e / f )

preorderTraversal (rot,info,left,right,stakk)

/* Rutinen gjennomløper et binært tre vha preorder traversal */

slutt := 0 ref := rotIF ref = slutt THEN // tomt tre

tom := trueELSE // ikke-tomt tre

tom := falsepush(stakk,slutt) // initier stakkWHILE ref != slutt // gjennomløping

prosess(info[ref]) // prosess for hvert elementIF right[ref] != slutt THEN // finnes høyre-barn?

push(stakk,right[ref]) // lagre peker til høyre barnENDIFref := left[ref] // søk gjennom venstre subtreIF ref = slutt THEN // ikke flere venstre subtre

pop(stakk,ref)ENDIF

ENDWHILEENDIF

*-

/cb

e f

a

+

Preorder traversalRekursjon - 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 THENprosess(info[rot])preorderTraversal(left[rot])preorderTraversal(right[rot])

ENDIF

*-

/cb

e f

a

+

Preorder traversalRekursjon - Dynamiske elementer

preorderTraversal (rot)

/* Rutinen gjennomløper et binært tre *//* vha preorder traversal *//* Rekursjon benyttes.*//* rot : Peker til treets rot */

IF rot != null THENprosess(rot.info)preorderTraversal(rot.left)preorderTraversal(rot.right)

ENDIF

*-

/cb

e f

a

+

Preorder – Inorder – Postorder traversal

IF rot != null THENprosess(rot.info)preorderTraversal(rot.left)preorderTraversal(rot.right)

ENDIF

Preorder

IF rot != null THENinorderTraversal(rot.left)prosess(rot.info)inorderTraversal(rot.right)

ENDIF

Inorder

IF rot != null THENpostorderTraversal(rot.left)postorderTraversal(rot.right)prosess(rot.info)

ENDIF

Postorder

Sortering vha binært tre

90

25

12

15

8

7

102

5

19

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 traverseringgi elementene i sortert rekkefølge.

Sortering vha binært tre

90

25

12

15

8

7

102

5

19

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....

19 - 5 - 10 - 7 - 25 - 8 - 15 - 90 - 12 - 2

Innsetting i sortert binært tre

90

25

12

15

8

7

102

5

19

Innsetting av et element med info = N i et sortert binær tregjø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 = 1414 < 19 gå til venstre14 > 5 gå til høyre14 > 10gå til høyre14 < 15gå til venstre14 > 12gå til høyre

Resultat:N = 14 settes inn som høyre barn til 12

Innsetting i et sortert binært treAlgoritme

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 ENDIF

ENDIFENDIF

90

25

12

15

8

7

102

5

19

Slettting i binært tre

ÅseTrine

Renate

RolfOla

Per Truls

Stine

MartinKjell

LarsGrete

Kari

NilsInorden gjennomløpingav det binære treet girelementene 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

ÅseTrineRenate

Ola

Per Truls

Rolf

MartinKjell

LarsGrete

Kari

Nils

ÅseTrine

Renate

RolfOla

Per Truls

Stine

MartinKjell

LarsGrete

Kari

Nils

Stine skal fjernes.

Erstatt Stine med største element i venstre subtre hvor Stine er rot, dvs Rolf.

Sletting i binært tre

3

2

1 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 - AlgoritmeCase 1: Noden som skal slettes har ingen barn

sletting_1 (info,left,right,spek,pPek,rot,led)

null := 0IF ppek = null THEN // Fjerning av rotrot := null

ELSE // Forelder finnes IF sPek = Left[pPek] THEN

left[pPek] := null ELSE right[pPek] := null ENDIFENDIFleft[sPek] := led // Lediglisteled := sPek

pPek

sPek

Sletting i et sortert binært tre - AlgoritmeCase 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 := 0IF ppek = null THEN // Fjerning av rotrot := right[sPek]

ELSE // Forelder finnes IF sPek = Left[pPek] THEN

left[pPek] := right[sPek] ELSE right[pPek] := right[sPek] ENDIFENDIFleft[sPek] := led // Lediglisteled := sPek

pPek

sPek

Case 1 er etspesialtilfelleav Case 2

Sletting i et sortert binært tre - AlgoritmeCase 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 := 0peker := left[sPek] // erst. slettet e.IF ppek = NULL THEN // Fjerning av rotrot := peker

ELSE // Forelder finnes IF left[pPek] = sPek THEN

left[pPek] := peker ELSE right[pPek] := peker ENDIFENDIFright[peker] := right[sPek] // Flyttet elementleft[sPek] := led // Lediglisteled := sPek

pPek

sPek

sletting_3_2 (info,left,right,spek,pPek,rot,led)

null := 0peker := left[sPek]forrige := pekerWHILE right[peker] != null

forrige := pekerpeker := right[peker]

ENDWHILEIF ppek = NULL THEN // Fjerning av rot

rot := pekerELSE // Forelder finnes IF left[pPek] = sPek THEN

left[pPek] := peker ELSE right[pPek] := peker ENDIFENDIFright[peker] := right[sPek]right[forrige] := left[peker]left[peker] := left[sPek]left[sPek] := led // Lediglisteled := sPek

pPek

sPek

Sletting i et sortert binært tre - AlgoritmeCase 3.2: Noden som skal slettes har et venstre-barn.

Venstre-barn til noden som skal slettes har høyre-barn.

Ulike strukturer av binært tre

fe

/c

*

ba

-

+

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

Tredde trær

fe

/c

*

ba

-

+

I såkalte tredde trær benyttes såkalte Tpekere (opprinnelige null-pekerefra 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

Rot

+

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

Rot

Head

*-

/cb

e f

a

+

RightLeftInfo

Led

3

1Head 12 1

b -9 -12

7

* 13 10

e -4 -10

a -1 -9

8

14

- 6 2

/ 5 11

f -10 -1

+ 9 4

c -9 -4

15

015

14

13

12

11

10

9

8

7

6

5

4

3

2

1

Tredde trærtreddInorder - Algoritme

treddInorder (info,left,right,rot,tom)

peker := rotIF Abs(left[peker]) = rot THEN // tomt tre

tom := trueELSE // Ikke-tomt tre tom := false REPEAT

IF right[peker] < 0 THEN // Tpekerpeker := abs(right[peker])

ELSE // Ordinær pekerpeker := 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]) ENDIF UNTIL peker = rot // Hele treet gjennomløptENDIF

Balanserte trær

BF = v - h

Høydeh

Høydev

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ærmetsamme 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

0

0

1

-20

-2

0

-1

4

1

0 0

-2 0

3

-4

1

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 subtreetsom har PIVOT-noden som rot.Det kan vises at ingen andre noder i treet får sin balansefaktor endretved AVL-rotasjoner.

3. Hvis absoluttverdien av balansefaktoren for PIVOT-noden ble endretfra 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 attreet’s ordnings-rekkefølge blir uendret.

Case 1:

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

BF=0

BF=0

PivotPivot

Pivot

LS

Etter AVL-rotasjon

Etter innsetting

Innsatt nytt elementFør innsetting

h+2

RPRS

S

P

BF=+1BF=0

BF=+2BF=+1

h

h+2

LS

RP

RS

S

P

RP

RSLS

S

P

Case 1:

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

BF=0

BF=0

PivotPivot

Pivot

LS

Etter AVL-rotasjon

Etter innsetting

Innsatt nytt elementFør innsetting

h+2

RPRS

S

P

BF=+1BF=0

BF=+2BF=+1

h

h+2

LS

RP

RS

S

P

RP

RSLS

S

P 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] // 1rPek := right[lPek] // 2right[lPek] := pivot // 3left[pivot := rPek // 4pivot := lPek // 5bf[pivot] := 0 // 6bf[right[pivot]] := 0 // 7

lPek (1)

rPek (2)

3

pivot (5)

4

Case 2:

Innsetting i høyre subtretil høyre barn til Pivot-node

BF=0

BF=0

LP

RS

PivotPivot

Pivot

RS

Etter AVL-rotasjon

Etter innsettingFør innsetting

h+2

LS

S

P

BF=-1BF=0

BF=-2BF=-1

h

h+2

LPLS

S

P

RSLSLP

S

P

Case 3.1:

Innsetting i høyre subtretil venstre barn til Pivot-node

Etter AVL-rotasjon

BF=0BF=0PS

BF=0Pivot

N

Etter innsetting

Før innsetting

BF=0N

BF=-1S

PivotBF=+2

P

BF=0S

PivotBF=+1

P

Case 3.2:

Innsetting i venstre subtre til høyre barntil venstre barn til Pivot-node

BF=0

LTRP

RTLS

T

Pivot

Etter AVL-rotasjon

BF=-1

BF=0

h+2 S P

LT

BF=1

h-1

h

RP

RTLS

T

Pivot

Etter innsetting

BF=-1

BF=2

h

h+2

S

P

BF=0

h-1

h

RP

RTLTLS

T

Pivot

Før innsetting

BF=0

BF=1

h

h+2

S

P

Case 3.3:

Innsetting i høyre subtre til høyre barntil venstre barn til Pivot-node

RT

RT

BF=1

LTRPLS

T

Pivot

Etter AVL-rotasjon

BF=0

BF=0

h+2 S P

LT

BF=-1

RP

LS

T

Pivot

Etter innsetting

BF=-1

BF=2

h+2

S

P

BF=0

h-1

h

RP

RTLTLS

T

Pivot

Før innsetting

BF=0

BF=1

h

h+2

S

P

Case 4:

Innsetting i venstre subtre til høyre barntil Pivot-node

Algoritmene til Case 4 blir analoge med algoritmene til Case 3.

Generell tre

Kjell

AndersKnutIrene

RandiSigneOla

LarsGrete

PerÅseHansKari

Nils

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

Knut 1

Kjell 0Randi 0Signe 0Ola 0

Anders 0Irene 0Lars 3Grete 0

Hans 1 Per 0Åse 2Kari 2

Nils 4

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

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

KjellRandiSigne

Nils

Ola

AndersIreneGrete

Per

KnutLars

Hans ÅseKari

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.

Kjell

Randi

Signe

Nils

Ola

Anders

Irene

Grete

PerKnut

Lars

Hans

Åse

Kari

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

Ternary tre implementering (1/2)

Nils

LSøskenLBarn

RSøsken

Kari Hans Åse Per

Grete Lars Irene Knut Anders

Ola Signe Randi Kjell

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.

Nils

LSøskenLBarn

RSøsken

Kari

Hans

Åse

Per

Grete

Lars Irene

Knut

Anders

Ola

Signe

Randi

Kjell

Ternary tre implementering (2/2)

Hierarkisk datastruktur - Bil

Ford

Karosseri Motor

SylinderForgasser Dynamo

Tre-struktur / Hierarkisk struktur benyttes ofte der hvor det eraktuelt å 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 ?

Kant2

Kant3

Hjørne3

Kant1

Hjørne1

Hjørne2

Trekant

Hierarkisk datastruktur - Trekant (1/4)

Trekant

Kant1 Kant2 Kant3

Hjørne11 Hjørne12 Hjørne21 Hjørne22 Hjørne31 Hjørne32

Trekant

Kant1 Kant2 Kant3

Hjørne11 Hjørne12 Hjørne21 Hjørne22 Hjørne31 Hjørne32


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.


- 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.

Trekant

Kant1 Kant2 Kant3 Hjørne1 Hjørne2 Hjørne3


Trekant:- Type- Peker til første kant- Peker til første hjørne- Peker til neste element

Hjørne:- Type- XKoordinat- YKoordinat- Peker til neste hjørne- Peker til foreldre

Kant:- Type- Peker til endepunt 1- Peker til endepunt 2- Peker til neste kant

E1

E2E3

K1

K3

K2

K4

K5

K6K7

K8

K9

H1

H2

H3

H4

H7

H5

H6H8

H9

Hierarkisk datastruktur - Multiple trekanter



Kant:- Type- Peker til endepunt 1- Peker til endepunt 2- Peker til neste kant- Peker til tilsluttet kant- Peker til nabo-trekant

Grafisk system

E1 E2 E3

K1 K2 K3 H1 H2 H3 K4 K5 K6 H4 H5 H6 K7 K8 K9 H7 H8 H9

Hierarkisk datastruktur - Grafisk system



Kant:- Type- 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++

Tree

Node

Node

Node

Node

Node

Node

Node

Node

Node

Node

Element

TreeIterator

Root

En klasse Tnodeutgjø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 TreeIteratorscanner treet.

Klassehierarki - Tre

GeneralTreeI_Tree Test

I_Container A_Container

I_Comparable A_Object

A_Tree

I_SearchableContainer

I_SearchTree

BinaryTree

BinarySearchTree

I_PreInPostVisitor A_PreInPostVisitor PreOrder

InOrder

PostOrder

Test

Test

Interface I_Tree

Interface I_Tree som gir grensesnittet for datastrukturen tre:

A

B D

C E G H

F

depthFirstTraversal

depthFirstTraversal omfatter de tre spesialtilfellene:- PreOrder- InOrder (kun for binære trær)- PostOrder

For å kunne håndtere disse tre spesialtilfellene, benytterdepthFirstTraversal parametertypen I_PreInPostVisitor.For å kunne sende en I_Visitor til depthFirstTraversallages en såkalt adapter (konverterer et interface nødvendigfor en klasse over til et annet interface nødvendig for en annen klasse).Vi benytter 3 slike adaptere: Klassene PreOrder, InOrder og PostOrdersom alle implementerer I_PreInPostVisitor.

I_Visitor v = new …Visitor( );I_Tree t = new …Tre( );…t.depthFirstTraversal (new PreOrder(v));…

A

B D

C E G H

F

Interface I_PreInPostVisitor

Interface I_PreInPostVisitor for dybde-først gjennomløp av et tre:

A

B D

C E G H

F

Abstract class A_PreInPostVisitor

class PreOrder

class InOrder

class PostOrder

abstract class A_TreedepthFirstTraversal

A

B D

C E G H

F

abstract class A_TreebreadthFirstTraversal

A

B D

C E G H

F

abstract class A_Treeaccept

A

B D

C E G H

F

abstract class A_TreegetEnumeration

En parameter visitor av typen I_PreInPostVisitor følger med.

A

B D

C E G H

F

abstract class A_TreeTreeEnumeration

A

B D

C E G H

F

abstract class A_TreeTreeEnumerationhasMoreElements - nextElement

A

B D

C E G H

F

abstract class A_TreegetRoot – getSubtreegetDegree- getHeight - isLeaf

A

B D

C E G H

F

Generelt tre

A

B D

C E G H

F

A

B D

E

F

G H

Benytter en liste over alle barna til en gitt node

C

Generelt treconstructor

A

B D

C E G H

F

Generelt tregetRoot - getDegree - getSubtree

A

B D

C E G H

F

Generelt treattachSubtree - detachSubtree

A

B D

C E G H

F

Generelt treisLeaf - isEmpty - removeAll

A

B D

C E G H

F

Test Generelt tre (1/2)

A

B C

D

Test Generelt tre (2/2)

A

B C

D

Binært treBruk av eksterne (tomme) noder

A

B D

C E G

F

A

B

C

Ø Ø

Ø

D

E

Ø F

G

Ø Ø

Ø Ø

Binært treconstructors

A

B D

C E G

F

Binært tregetRoot - getLeft - getRight

A

B D

C E G

F

Binært treattachLeft - attachRight

A

B D

C E G

F

Binært treisEmpty - isLeaf - removeAll

A

B D

C E G

F

Binært tredeptFirstTraversal

A

B D

C E G

F

Binært trebreadthFirstTraversal

A

B D

C E G

F

Test Binært tre (1/2)

A

B C

D

Test Binært tre (2/2)

A

B C

D

interface I_SearchTree

A

B D

C E G

F

BinarySearchTreegetLeftBST - getRightBST

A

B D

C E G

F

BinarySearchTreefind

A

B D

C E G

F

BinarySearchTreefindMin - findMax

A

B D

C E G

F

BinarySearchTreeinsert - attachRoot - balance

A

B D

C E G

F

BinarySearchTreeremove

A

B D

C E G

F

BinarySearchTreeisMember

A

B D

C E G

F

Test BinarySearchTree

A

C B

D

ENDENDENDEND

Kap 09 Tre

Documents

Transcript of Kap 09 Tre