Presentasjon lastes. Vennligst vent

Presentasjon lastes. Vennligst vent

Kap 09 Tre. Slektstre Slektstre med ulike generasjoner (foreldre, barn, barnebarn, …)

Liknende presentasjoner


Presentasjon om: "Kap 09 Tre. Slektstre Slektstre med ulike generasjoner (foreldre, barn, barnebarn, …)"— Utskrift av presentasjonen:

1 Kap 09 Tre

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

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

4 Filkataloger

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

6 Tre - Definisjon T = {R} U T 1 U T 2 U … U T n ={R, T 1, T 2, …, T n } 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 T 1, T 2, …, T n hvor hver T i selv er et tre.

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

8 Tre - Definisjoner T ={R, T 1, T 2, …, T n } 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 R i i subtreet T i til treet T kalles et barn til R. Tilsvarende defineres barnebarn, …. Roten R i treet T kalles foreldreelement til alle røttene R i i subtreet T i 1 < i <= n. Tilsvarende defineres besteforeldre. To røtter R i og R j av distinkte subtrær T i og T j i treet T kalles søsken.

9 Tre - Eksempler A BD CEGH F 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

10 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 = {v 1, v 2, …, v k } hvor v i  V for 1 <= i <= k slik at den i-te noden v i er foreldreelement til den (i+1)-te noden v i+1. Lengden av veien P er k-1. A BD CEGH F Veien P = {A, D, E, F}har lengde 3. Veien P = {D,H} har lengde 1. Veien P = {B} har lengde 0.

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

12 Tre - Definisjoner A BD CEGH F 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

13 N-ary Tre - Definisjon T ={R, T 0, T 1, …, T N-1 } hvor hver T i 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.

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

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

16 N-ary Tre - Teorem Eksempel A BD CEGH F N = 3 Interne noder:n = 8 Eksterne noder:e = (N-1)n+1 = (3-1)8+1 = 17

17 N-ary Tre - Teorem 9.2 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: (N h+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 (N )/(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 (N k+1 -1)/(N-1) interne noder. Maksimalt antall interne noder er derfor: N(N k+1 -1)/(N-1)+1 = (N k+2 -1)/(N-1) …… 1 k k+1

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

19 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)(N h+1 -1)/(N-1) + 1 = N h+1 n max Hint (fra teorem 9.1): e max = (N-1)n max + 1

20 N-ary Tre - Corollar 9.2 N = 3 Høyde = 3 Maksimalt antall eksterne noder = N h+1 = = 3 4 = 81

21 N-ary Tre - Teorem 9.3 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: N h 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 N 0 = 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 N k løv. Maksimalt antall løv er derfor N x N k = N k+1 …… 1 k k+1

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

23 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, T L, T R } T L og T R kalles for henholdsvis venstre subtre og høyre subtre. A BC D A BC D =

24 Tre gjennomløping Tre gjennomløping: -Breddeførstgjennomløp -Dybde førstgjennomløp -PreOrden gjennomløp -InOrdengjennomløp(kun for binært tre) -PostOrdengjennomløp A BD C EH F

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

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

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

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

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

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

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

32 Aritmetisk tre ( 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 mellom de to operandene plassert som venstre og høyre subtre. Operand Operator

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

34 Aritmetisk tre InOrden gjennomløp ( a - b ) + c * ( e / f ) 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 )))

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

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

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

38 Heap En heap er en trestruktur med følgende undergrupper: MaxHeapGenerelt tre hvor hver node har nøkkelverdi større enn eller lik nøkkelverdi til hvert av sine barn MaxBinHeapBinært tre hvor hver node har nøkkelverdi større enn eller lik nøkkelverdi til hvert av sine barn MinHeapGenerelt tre hvor hver node har nøkkelverdi mindre enn eller lik nøkkelverdi til hvert av sine barn MinBinHeapBinært tre hvor hver node har nøkkelvedi mindre enn eller lik nøkkelverdi til hvert av sine barn Heap er hensiktsmessig bl.a. ved sortering, prioritetskø og komprimering

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

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

41 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

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

43 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 ELSE child:=n// stop ENDIF ENDWHILE ENDIF

44 Heap Building a max binary heap - Algorithm Build_MaxBinHeap (a,n) FOR i := 2 TO n DO Insert_MaxBinHeap(a,i-1,a[i]) ENDFOR 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]

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

46 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 swapRearrange i = i = i = i = i =

47 Heap HeapSort - Algorithm [2/2] swapRearrange i = i = i = i = i =

48 Data-komprimering Ascii-tabell Skrivbare tegn Ascii-kode: = = 128 Skrivbare tegn BinærtDecTegn Space ! … ( A B C … a b c …

49 Data-komprimering BinærtDecTegn Space ! … ( A B C … a b c … … Hallo Hallo

50 Data-komprimering Huffman encoding - Prioritetskø vha Heap TegnFrekvens A5 B2 C3 D4 E10 F1 D 4B 2 A 5E 10C 3 MinBinHeap La vanlige tegn ha korte bitsekvenser, mens uvanlige tegn får lange bitsekvenser

51 Data-komprimering Huffman encoding - Prioritetskø vha Heap Huffman_Encoding 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 Z 5 25 E 10Z 4 15 Z 2 6Z 3 9 Z 1 3C 3D 4A 5 F 1 B 2 E C 101 D 110 A 111 F 1000 B 1001

52 Symbolsk derivasjon Derivasjon benyttes til å beskrive prosessendringer Newtons 2.lov Radioaktivitet Kvantefysikk SHM Varmetransport Bølger Elektrisk krets Typer av diff.lign. ODEOrdinæreEndringer mht en enkelt variabel PDEPartielleEndringer mht flere variabler

53 Symbolsk derivasjon Info om derivasjon - Def / Numerisk / Symbolsk y = xcosxy’ = 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. Numerisk derivasjon Symbolsk derivasjon y = 0.25x 2 y’ = 0.5x

54 Symbolsk derivasjon Noen enkle derivasjonseksempler y = 4 y’ = 0 y = x 2 y’ = 2x y = x n y’ = cosx y = sinx y = e x y’ = e x y’ = nx n-1 y = c y’ = 0 y = 4y’ = 0 y = cy’ = 0 y = x y’ = 1 y = x 2 y’ = 2x y = x 3 y’ = 3x 2 y = x n y’ = nx n-1 y = sin(x)y’ = cos(x) y = cos(x)y’ = -sin(x) y = e x y’ = e x

55 Symbolsk derivasjon Avansert derivasjonseksempel

56 Symbolsk derivasjon Algoritme - Gjennomgang av derivasjonseksempel y = x 2 sin4x y’ = 2xsin4x + x 2 cos4x  4 = 2xsin4x + 4x 2 cos4x y = x 2 sin4x y’ = 2xsin4x + 4x 2 cos4x

57 Symbolsk derivasjon Aritmetisk tre - binTree y = x 2 sin4x ^ * 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 fra infix til postfix binTree

58 Symbolsk derivasjon Strategi * 2 x u= 2 du= 0 v= x dv= 1 y=2  x y’=du  v + u  dv =0  x + 2  1 =2 * op x2x2 sinx u= x 2 du= 2x v= sinx dv= cosx y=x 2  sinx y’=du  v + u  dv =2xsinx + x 2 cosx op1op2 u= op1 du= op1’ v= op2 dv= op2’ 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. Operator Operand

59 Symbolsk derivasjon Funksjoner - Oversikt differentiateStack dSwitch get_op_sum get_differentiatio n get_operand get_op_diff get_op_prod get_op_div get_op_sin get_op_cos...

60 Symbolsk derivasjon differentiateStack

61 Symbolsk derivasjon get_operand

62 Symbolsk derivasjon get_differentiation

63 Symbolsk derivasjon dSwitch

64 Symbolsk derivasjon get_op_...

65 Symbolsk derivasjon get_op_pot

66 Symbolsk derivasjon Derivasjon - Venstre subtre y = x 2 sin4x op=* u = du = v = dv = out= dS (*) x ^ 2 * sin(4*x) x 2 ^ 4 x * sin * get_op (^) x2x2 dS (^) get_op (x) x get_diff (x) 1 dSwitch (^,x,1,2,0) get_op_pot (x,1,2,0) 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

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

68 Symbolsk derivasjon Derivasjon - Høyre / Høyre subtre y = x 2 sin4x op=sin u = 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) op=* u = du = v = dv= out= op=4 … out= dS (4) get_op (x) op=x … out= dS (x) 1 get_diff (x) 1 x 4x 4 0 0

69 Symbolsk derivasjon Derivasjon - Høyre subtre y = x 2 sin4x op=sin u = du = v =4x dv =4 out= 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)

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

71 Lenket liste implementering av binært tre -infoData-informasjon -leftPeker til venstre barn -rightPeker 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 )

72 Preorder traversal ( a - b ) + c * ( e / f ) a 45+-ab 59+-ab* 69+-ab*c 77+-ab*c/ 87+-ab*c/e 9+-ab*c/ef Step Stakk Output Preorden gjennomløping av et tre vha en stakk hvor evnt peker til høyre barn plasseres.

73 Preorder traversal Algoritme - 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 := 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) ENDIF ENDWHILE ENDIF

74 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

75 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

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

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

78 Sortering vha binært tre 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 Tallet 10 leses er mindre enn 19, derfor går vi til venstre for er større enn 5, derfor plasseres 10 som høyre barn til

79 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 = < 19 gå til venstre 14 > 5gå til høyre 14 > 10gå til høyre 14 < 15gå til venstre 14 > 12gå til høyre Resultat: N = 14 settes inn som høyre barn til 12

80 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 ENDIF

81 Slettting i binært tre 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.

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

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

84 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

85 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

86 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

87 sletting_3_2 (info,left,right,spek,pPek,rot,led) null := 0 peker := left[sPek] forrige := peker WHILE right[peker] != null forrige := peker 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 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.

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

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

90 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

91 Tredde trær - Lenket liste vha array

92 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]) ENDIF UNTIL peker = rot // Hele treet gjennomløpt ENDIF

93 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

94 Balansefaktor - Eksempel 5

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

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

97 Case 1: Innsetting i venstre subtre til venstre barn til Pivot-node [2/2] 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 lPek (1) rPek (2) 3 pivot (5) 4

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

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

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

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

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

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

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

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

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

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

108 Ternary tre implementering (2/2)

109 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 ?

110 Hierarkisk datastruktur - Trekant (1/4)

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

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

113 Hierarkisk datastruktur - Trekant (4/4) 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

114 Hierarkisk datastruktur - Multiple trekanter 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 - Peker til tilsluttet kant - Peker til nabo-trekant

115 Hierarkisk datastruktur - Grafisk system 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 - Peker til tilsluttet kant - Peker til nabo-trekant

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

117 Klassehierarki - Tre GeneralTree I_Tree Test I_ContainerA_Container I_ComparableA_Object A_Tree I_SearchableContainer I_SearchTree BinaryTree BinarySearchTree I_PreInPostVisitor A_PreInPostVisitorPreOrder InOrder PostOrder Test

118 Interface I_Tree Interface I_Tree som gir grensesnittet for datastrukturen tre: A BD CEGH F

119 depthFirstTraversal 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_Treet=new …Tre( ); … t.depthFirstTraversal (new PreOrder(v)); … A BD CEGH F

120 Interface I_PreInPostVisitor Interface I_PreInPostVisitor for dybde-først gjennomløp av et tre: A BD CEGH F

121 Abstract class A_PreInPostVisitor

122 class PreOrder

123 class InOrder

124 class PostOrder

125 abstract class A_Tree depthFirstTraversal A BD CEGH F

126 abstract class A_Tree breadthFirstTraversal A BD CEGH F

127 abstract class A_Tree accept A BD CEGH F

128 abstract class A_Tree getEnumeration En parameter visitor av typen I_PreInPostVisitor følger med. A BD CEGH F

129 abstract class A_Tree TreeEnumeration A BD CEGH F

130 abstract class A_Tree TreeEnumeration hasMoreElements - nextElement A BD CEGH F

131 abstract class A_Tree getRoot – getSubtree getDegree- getHeight - isLeaf A BD CEGH F

132 Generelt tre A BD CEGH F A B D E F GH Benytter en liste over alle barna til en gitt node C

133 Generelt tre constructor A BD CEGH F

134 Generelt tre getRoot - getDegree - getSubtree A BD CEGH F

135 Generelt tre attachSubtree - detachSubtree A BD CEGH F

136 Generelt tre isLeaf - isEmpty - removeAll A BD CEGH F

137 Test Generelt tre (1/2) A BC D

138 Test Generelt tre (2/2) A BC D

139 Binært tre Bruk av eksterne (tomme) noder A BD CEG F A B C ØØ Ø D E ØF G ØØ ØØ

140 Binært tre constructors A BD CEG F

141 Binært tre getRoot - getLeft - getRight A BD CEG F

142 Binært tre attachLeft - attachRight A BD CEG F

143 Binært tre isEmpty - isLeaf - removeAll A BD CEG F

144 Binært tre deptFirstTraversal A BD CEG F

145 Binært tre breadthFirstTraversal A BD CEG F

146 Test Binært tre (1/2) A BC D

147 Test Binært tre (2/2) A BC D

148 interface I_SearchTree A BD CEG F

149 BinarySearchTree getLeftBST - getRightBST A BD CEG F

150 BinarySearchTree find A BD CEG F

151 BinarySearchTree findMin - findMax A BD CEG F

152 BinarySearchTree insert - attachRoot - balance A BD CEG F

153 BinarySearchTree remove A BD CEG F

154 BinarySearchTree isMember A BD CEG F

155 Test BinarySearchTree A CB D

156 ENDEND


Laste ned ppt "Kap 09 Tre. Slektstre Slektstre med ulike generasjoner (foreldre, barn, barnebarn, …)"

Liknende presentasjoner


Annonser fra Google