Puud Puu (programmeerimises tavaliselt järjestatud puu):

Presentasjon om: "Puud Puu (programmeerimises tavaliselt järjestatud puu):"— Utskrift av presentasjonen:

1 Puud Puu (programmeerimises tavaliselt järjestatud puu):
- dünaamiline andmestruktuur - komponentideks nn. puu tipud: juurtipp e. juur, vahetipud ,lehed - peegeldab ranget hierarhiat: juurtipp on kõige kõrgema taseme “ülemus”, kõigil ülejäänud tippudel on täpselt üks ülemus.

2 Puud - alluvateta tipud = puu lehed, kõik ülejäänud (v.a. juur) tipud on vahetipud - sama ülemuse alluvad – kolleegid, naabrid - järjestatud puu korral on oluline iga tipu alluvate (naabrite) omavaheline järjestus

3 Näide: aritmeetilise avaldise puu
“Tavaline” kuju: ( ) * / Pööratud poola kuju: 2 1 – 4 * 6 3 / Prefikskuju sulgudega: + ( * ( - (2,1), 4), / (6,3)) Postfikskuju sulgudega: (((2,1) - , 4) * ,(6,3) / ) + Juur + * / - 2 1 4 6 3 Lehed

4 Puu läbimine Eesjärjestus (pre-order): - Töödelda juur
- Töödelda juure alampuud järjestuses vasakult paremale Lõppjärjestus (post-order, end-order): Millises järjestuses toimub aritmeetilise avaldise väärtuse arvutamine?

5 Puu läbimine Pre: ABDGHEFICJ Post: GHDEIFBJCA A B C D E F J I G H

6 Puu esitlusviisid Graafiline (joonisel)
Vasakpoolne suluesitus A(B(D(G,H),E,F(I)),C(J)) Parempoolne suluesitus (((G,H)D,E(I)F)B,(J)C)A Tekstiline “treppimine”

7 Puu esitlusviisid Tekstiline “treppimine” A B D G H E F I C J

8 Puu esitlusviisid Tippudele viitamine liitnimedega A, A.B, A.C, A.B.D, A.B.E, A.B.F, A.B.D.G, A.B.D.H, A.B.F.I, A.C.J Mittejärjestatud puu esitamiseks sobivad ka graafi esitlusviisid (vajadusel fikseerida juurtipp) – näit. külgnevusmaatriks vms.

9 Puu esitlusviisid Puu esitlusviisid töötlemiseks arvutis sõltuvad lahendatavast ülesandest – universaalset “parimat” kujutlusviisi ei leidu: - tekstilised esitlused - viidastruktuurid - peitmine muude mehhanismide sisse - …

10 Puu kujutamine ahelate abil
Igas tipus on viit tema ülemusele (juurtipus nullviit). Puudus: puu tippe ei saa lähtudes juurtipust süstemaatiliselt “läbi käia”. Saab teha töötlust “alt üles”, kui on korraldatud juurdepääs lehtede hulgale

11 Puu kujutamine ahelate abil
Igast tipust lähtub selle tipu vahetute alluvate ahel (lehtede korral tühi ahel) ning viit (parempoolsele) naabrile. Puudus: antud tipust ei pääse lisavõimalusi (näit. magasini) kasutama “üles”. Kasulik rekursiivsete töötlusprogrammide korral.

12 Puu kujutamine arvutis
Nn. kahendpuu tipus on viit vasakule alampuule ning viit paremale alampuule. Läbimiseks kasutada magasini või rekursiivset algoritmi.

13 I import java.util.*; /** Puu tipp. Käsitleme puu tippu ka alampuu juurena ning * naabrite loetelu elemendina. */ public class Tipp implements java.util.Enumeration { /** tippu identifitseeriv sõne. */ String nimi; /** viit tipu parempoolsele naabrile või null. */ Tipp paremNaaber; /** viit tipu esimesele alluvale või null. */ Tipp esimAlluv;

14 /** tipu konstruktor. */
Tipp (String s, Tipp p, Tipp a) { paneNimi (s); paneParemNaaber (p); paneEsimAlluv (a); } Tipp() { /** teisene konstruktor. */ this ("", null, null); Tipp (String s) { this (s, null, null); Tipp (String s, Tipp p) { this (s, p, null);

15 /** nime panemine. */ public void paneNimi(String s) { nimi = s; } /** tagastab nime. */ public String votaNimi() { return nimi; /** väärtustab viida parempoolsele naabrile. */ public void paneParemNaaber (Tipp p) { paremNaaber = p;

16 /** tagastab parempoolse naabri. */
public Tipp votaParemNaaber() { return paremNaaber; } /** väärtustab viida esimesele alluvale. */ public void paneEsimAlluv (Tipp a) { esimAlluv = a; /** tagastab esimese alluva. */ public Tipp votaEsimAlluv() { return esimAlluv;

17 /** teisendus sõneks (ainult tipp) */
public String toString() { return votaNimi(); } /** tipu töötlemine (katta üle alamklassides). */ public void tootleTipp() { System.out.print (votaNimi() + " "); /** naabrite Enumeration. */ public boolean hasMoreElements() { return (votaParemNaaber() != null);

18 /** naabrite Enumeration. */
public Object nextElement() { return votaParemNaaber(); } /** alluvate loetelu. */ public Enumeration alluvad() { return votaEsimAlluv(); /** kas tipp on leht. */ public boolean onLeht() { return (votaEsimAlluv() == null);

19 /** alluva lisamine viimaseks alluvate loetelus. */
public void lisaAlluv (Tipp a) { if (a == null) return; Enumeration alluvad = alluvad(); if (alluvad == null) paneEsimAlluv (a); else { while (alluvad.hasMoreElements()) alluvad = (Tipp)alluvad.nextElement(); ((Tipp)alluvad).paneParemNaaber (a); }

20 public int size() { /** (alam)puu tippude arv (koos juurega). */
int n = 1; // juur ise Enumeration alluvad = alluvad(); while (alluvad != null) { n = n + ((Tipp)alluvad).size(); alluvad = (Tipp)alluvad.nextElement(); } return n; public void preorder() { /** puu läbimine eesjärjekorras. */ tootleTipp(); ((Tipp)alluvad).preorder();

21 /** puu läbimine lõppjärjekorras. */
public void postorder() { Enumeration alluvad = alluvad(); while (alluvad != null) { ((Tipp)alluvad).postorder(); alluvad = (Tipp)alluvad.nextElement(); } tootleTipp();

22 /** konkreetse puu tegemine. */
public static Tipp tehaPuu() { Tipp juur = new Tipp ("+", null, new Tipp ("*", new Tipp ("/", null, new Tipp ("6", new Tipp ("3", null, null), null)), new Tipp ("-", new Tipp ("4", null, null), new Tipp ("2", new Tipp ("1", null, null), null)))); return juur; }

23 /** peameetod silumiseks. */
public static void main (String[] param) { Tipp t = tehaPuu(); System.out.println (t.size()); System.out.print ("Preorder: "); t.preorder(); System.out.println(); System.out.print ("Postorder: "); t.postorder(); } // main lõpp

24 Graafid G=(V,E), V-lõplik tippude hulk E on alamhulk hulgast VV
Orienteerimata graafid Orienteeritud graafid E nim. servade hulgaks

25 Graafid G=(V,Ø) – nullgraaf Täisgraaf G={V,V×V\{v,v}v  V}
Tee tipust u tippu v on tippude jada (u,w0), (w0,w1), …(wn,v), kus kõik need paarid on servad. Sidus graaf Nõrgalt sidus – suundade ärajätmisel saab sidusaks

26 Graafid G1=(V1,E1) on graafi G=(V,E) alamgraaf, kui V1V ja E1=EV1V1
Külgnevusmaatriks on |V |  | V| maatriks A=a[i][j], milles a[i][j]=1, kui kaar (i,j)E ning 0 vastasel juhul. Multigraafi korral a[i][j] tipust i tippu j viivate teede arv

27 Graafid Graafi G transitiivne sulund G+ saadakse lähtegraafile kõigi niisuguste kaarte (u,v) lisamisel, mille korral leidub tee tipust u tippu v Ahel – tee, milles servad ei kordu Lihtahel – ahel, milles ka tipud ei kordu Tsükkel – nullist suurema pikkusega kinnine ahel Lihttsükkel – kinnine lihtahel Euleri ja Hamiltoni ahelad, tsüklid

28 Graafid Kauguste maatriks D=d[i][j] on |V |  | V | maatriks, milles d[i][j] on kaare (i,j) “pikkus” Adj(v)={eE |w V: e=(v,w)} Külgnevusstruktuur on hulk {(v, Adj(v)) | v V}

29 Graafide kujutamine Joonis (nt .tasandilised graafid)
Kaarte loetelu (kaarega peab siis lisanduma ka otspunktide kohta käiv informatsioon) Külgnevusmaatriks (kaaslusmaatriks) Külgnevusstruktuur – tippude loetelu, milles iga tipuga seotud sellest lähtuvate kaarte loetelu, kaare suubumistipud

30 Graafi kujutamine külgnevusstruktuuri abil

31 Graafi kujutamine külgnevusstruktuuri abil

32 interface AbstrGraaf {
boolean lisaTipp (AbstrTipp t); //kas sai lisada? boolean eemaldaTipp (AbstrTipp t); //kas sai eemaldada? AbstrTipp leiaTipp (String nimi); //nime jargi tipu leidmine String toString (); //va"ljatru"kiks vajalik }

33 interface AbstrTipp { String votaNimi (); //tipu nime leidmine boolean lisaValjuvkaar (AbstrKaar k); //kas sai lisada? boolean eemaldaValjuvkaar (AbstrKaar k); //kas sai eemaldada? }

34 interface AbstrKaar { boolean paneSuubuma (AbstrTipp t); String votaNimi (); //kaare nime leidmine }

35 class Element { //lisainfo tuleb lisada alamklassides
String nimi; Element jargmine; Element() { //konstruktor vaikimisi } Element (String s) { //konstruktor nimega isendite loomiseks paneNimi (s); public String votaNimi() { return nimi; public Element votaJargmine() { return jargmine;

36 public Element votaJargmine() {
return jargmine; } public void paneNimi (String s) { nimi = s; public void paneJargmine (Element e) { jargmine = e;

37 public Element lisa (Element e) { //annab uue alguse tagasi
if (e == null) return this; // ei olnudki soovi lisada if (e == this) return this; // ebanormaalne situatsioon niikuinii if (e.votaNimi().compareTo (votaNimi()) < 0) { // e.nimi < this.nimi e.paneJargmine (this); // lisamine ahela algusesse return e; } Element abi = this; // hakkame kohta otsima abi jarele while (abi.votaJargmine() != null) { if (e.votaNimi().compareTo (abi.votaJargmine().votaNimi()) < 0) { // lisamine abi jarele e.paneJargmine (abi.votaJargmine()); abi.paneJargmine (e); return this; abi = abi.votaJargmine();

38 abi.paneJargmine (e); // lisamine ahela loppu
e.paneJargmine (null); // igaks juhuks return this; } // lisa() lopp public Element eemalda (Element e) { //annab uue alguse voi null if (e == null) return this; //ei eemalda midagi if (e == this) return votaJargmine(); //esimese eemaldamine Element abi = this; while (abi != null) { if (e == abi.votaJargmine()) { abi.paneJargmine (e.votaJargmine()); } abi = abi.votaJargmine();

39 public Element otsi (String s) { //kui ei leia, siis null
Element abi = this; while (abi != null) { if (s.equals (abi.votaNimi())) return abi; abi = abi.votaJargmine(); } return null; } //Element lopp

40 class Graaf extends Element implements AbstrGraaf {
Tipp esimene; Graaf () { //konstruktor vaikimisi } Graaf (String s) { //konstruktor nimega graafi jaoks super(s); public Tipp votaEsimene () { return esimene; public void paneEsimene (Tipp t) { esimene = t;

41 public boolean lisaTipp (AbstrTipp t) {
if (votaEsimene() == null) { paneEsimene ((Tipp) t); return true; } paneEsimene ((Tipp) votaEsimene().lisa ((Tipp) t));

42 public boolean eemaldaTipp (AbstrTipp t) {
if (votaEsimene() == null) return false; paneEsimene ((Tipp) votaEsimene().eemalda ((Tipp) t)); return true; } public AbstrTipp leiaTipp (String s) { if (votaEsimene() == null) return null; return (Tipp) votaEsimene().otsi (s);

43 public String toString () {
String abi = "Graaf: " + votaNimi() + "\n"; Tipp t = votaEsimene(); while (t != null) { abi += t.votaNimi() + " --> "; Kaar k = t.votaEsimenevaljuv(); while (k != null) { abi += k.votaKuhusuubub().votaNimi() + " (" + k.votaNimi() + ") "; k = (Kaar) k.votaJargmine(); } abi += "\n"; t = (Tipp) t.votaJargmine(); return abi; } //Graaf lopp

44 class Tipp extends Element implements AbstrTipp {
Kaar esimenevaljuv; Tipp () { //konstruktor vaikimisi } Tipp (String s) { //konstruktor nimega tipule super (s); public Kaar votaEsimenevaljuv () { return esimenevaljuv; public void paneEsimenevaljuv (Kaar k) { esimenevaljuv = k;

45 public boolean lisaValjuvkaar (AbstrKaar k) {
if (votaEsimenevaljuv () == null) { paneEsimenevaljuv ((Kaar) k); return true; } paneEsimenevaljuv ((Kaar) votaEsimenevaljuv().lisa ((Kaar) k)); public boolean eemaldaValjuvkaar (AbstrKaar k) { if (votaEsimenevaljuv () == null) return false; paneEsimenevaljuv ((Kaar) votaEsimenevaljuv().eemalda ((Kaar) k)); } //Tipp lopp

46 class Kaar extends Element implements AbstrKaar {
Tipp kuhusuubub; Kaar () { //konstruktor vaikimisi } Kaar (String s) { //konstruktor nimega kaarele super (s); public Tipp votaKuhusuubub () { return kuhusuubub;

47 public void paneKuhusuubub (Tipp t) {
} public boolean paneSuubuma (AbstrTipp t) { paneKuhusuubub ((Tipp) t); return t != null; } //Kaar lopp

48 static public void main (String[] argumendid) {
System.out.println ("Tere"); Graaf g = new Graaf ("minugraaf"); Tipp t1 = new Tipp ("T1"); Kaar k1 = new Kaar ("K1"); g.lisaTipp (t1); Tipp t2 = new Tipp(); t2.paneNimi ("T0"); g.lisaTipp (t2); t1.lisaValjuvkaar (k1); k1.paneSuubuma (t2); System.out.println (g); //oluline, et toString() meetod oleks! System.out.println ("Lopp"); }

49 Programmi töö: Tere Graaf: minugraaf T0 --> T1 --> T0 (K1) Lopp

50 Külgnevusstruktuuri läbivaatus
Kuidas läbida graafi? “Töödelda” tipud ja kaared. Kasutusel abimuutujad tippude ja kaarte läbimiseks

51 Külgnevusmaatriksi ehitamine
Algul kõik M[i][j]=0 Iga kaare korral M[kaare_algus][kaare_lopp]++ Mida selle maatriksiga teha? Tehted maatriksitega, interpretatsioon Näiteks: M – linnadevaheliste lennuliinide olemasolu

52 Kauguste arvutamine Etteantud külgnevusmaatriksi järgi leida lühimad teepikkused kõigi tipupaaride vahe → kauguste maatriks Floyd-Warshalli algoritmi idee: iga tipu t korral vaadata läbi kõikvõimalikud teed kujul i→t→j. t=1..n i=1..n j=1..n if (M[i][t]+M[t][j]<M[i][j]) M[i][j]=M[i][t]+M[t][j]; Keerukuseks O(n3)

53 Tsükliteta orienteeritud graafi tippude topoloogiline sorteerimine
Leida graafi tippude selline transitiivne järjestus <<, mille korral mistahes kaare (vi, vj) korral vi<<vj Igal sammul eemaldatakse graafil üks eellasteta tipp. Tegelikul kasutusel konkretiseerida Ehituste planeering. Tööde tähtajad. Näide DME õpikust (lk. 86, ül. 24)

54 Graafi läbimise üldjuht
t olgu algtipp Adj(v)={eE |w V: e=(v,w)} Iga v V korral olek(v)=“uus”|”järjekorras”|”töödeldud” Q – järjekord (tippude hulk) Kuidas panna tippe järjekorda? Magasini? Kumb valida?

55 Graafi läbimine Laiuti, Q on tavaline järjekord – FIFO
Sügavuti, Q on magasin – LIFO Sõltuvalt ülesandest, nt. Djikstra algoritmis (vaatleme järgmises loengus) lühimate teede leidmiseks on Q muutuvate eelistustega järjekord Kas aritmeetikaavaldist kujutava puu “väärtuse” arvutamisel kasutame magasini või järjekorda?

56 Kaarte pikkused on võrdsed

57 Kaarte pikkused ei ole võrdsed

58 Veel Ülesanne: leida minimaalse kaarte arvuga tee antud tipust kõigisse teistesse tippudesse Lühimate teede erijuht, kui kaarte kaalud võrdsed Graafi läbimine laiuti, kus järjekorrast võetud tipu v järglased seotakse ahelasse: eellane(w)=v Kaarte arvu minimaalsuse tagab läbimise järjekord