Om binære søgetræer i Java

Om binære søgetræer i Java Mads Rosendahl 7. november 2002 Resumé En fix måde at gemme data på er i en træstruktur. Måden er nyttig hvis man får noget data ind og man gerne vil have at det gemt i en sorteret struktur så søgning efter det kan ske hurtigt. Denne note viser en simpel version af binære træer i java. Et binært træ er en struktur hvor hver punkt kan have op til to undertræer. Et sådant træ har et startpunkt man kalder roden, og når vi tegner træer vokser de nedad. Ann-Kristin Jannie Nicolas Rune Uffe Sådanne træer er især interessante hvis de er ordnede (dvs. sorterede). I et ordnet træ vil alt i et venstre undertræ være mindre end det der står i et højre undertræ. Det smarte ved en sådan ordnet træstruktur er at man ikke skal søge så langt ned i det for at finde ud af om noget er med, og det er også ret hurtigt at sætte nye ting ind i træstrukturen. Når man har binære træer som er ordnede kalder man dem også for binære søgetræer da de er særlig gode til søgninger. I eksemplet ovenfor er roden i træet, og det er ordnet alfabetisk, så f.eks. Jannie og Ann-Kristin kommer før og kommer efter. I en enkel form kan et binært træ erklæres med to klasser - et til roden og en til knuderne i træet. Hver knude indeholder så et element som kna være et vilkårligt objekt og to undertræer. Undertræerne er enten to nye knuder eller de kan have værdien null som viser at der ikke er et undertræ. 1

Erkæringen ser da således ud: class Tree{ Node root; class Node{ Object elem; Node left,right I Java er Object superklasse for alle andre klasser - aller andre klasser nedarver fra Object. Da vi imidlertid er interesseret i at kunne ordne (sortere) det der skal være i træet vil vi gerne have at de kan sammenlignes. Det er derfor smart at kræve at de er Comparable. I praksis betyder det at man skal skrive implements Comparable for de klasser man vil have objekter af i træet og disse klasser skal indeholde en metode med hovedet: public int compareto(object obj) Indsætt Når man skal indsætte nye elementer i et binært søgetræ skal man sørge for at kante sig ned igennem træet til der hvor elementet burde stå. Man sammenligner det der skal indsættes med elementerne i knuderne. Er det der skal indsættes mindre så sætter man det ind i venstre undertræ ellers i højre undertræ. Kommer den samme ting flere gange så indsætter man det også flere gang. Koden til dette så således ud. class Tree{ Node root=null; void insert(comparable obj){ if(root==null) root=new Node(obj,null,null); root.insert(obj); class Node{ Comparable elem; Node left,right; Node(Comparable obj,node l,node r){ elem=obj; left=l; right=r; void insert(comparable obj){ if(obj.compareto(elem)< 0){// dvs obj < elem if(left==null) left=new Node(obj,null,null); left.insert(obj); { if(right==null) right=new Node(obj,null,null); right.insert(obj); 2

Hver gang man skal indsætte noget i et undertræ checker man om det undertræ er null. Hvis det er så laver man blot en ny knude det pågældende sted, ellers kanter man sig ned i undertræet og undersøger hvor i undertræet det skal være. Eksempel. Lad os prøve et lille eksempel hvor vi indsæter følgende navne i et tomt træ:,, og Nicolas. Før vi indsætter har vi et tomt træ: Vi indsætter nu, og da root er null skal vi blot lave en knude til roden. Vi skal så indsætte og da kommer før må vi indsætte det i højre undertræ. Da right i s undertræ er null skal vi lave et nyt undertræ til Herefter skal vi indsætte. Vi ser først at det kommer til højre for og til venstre for og da venstre undertræ i sigurd s knude er null laver vi en ny knude der. 3

Til slut skal vi indsætte Nicolas. Det kommer til højre for og til venstre for og. Det skal derfor indsættes som venstre undertræ for Nicolas Hvis vi fortsatte med at indsætte Jannie, Ann-Kristin, Rune og Uffe vil vi få en struktur som vist i figuren i starten af denne note. Udskrivning Hvis man gerne vil udskrive elementerne i et binært søgetræ er det ikke så besværligt. man skal blot sørge for at udskrive venstre undertræer før højre undertræer - og ind imellem elementerne selv. Som Java kode ser det således ud: I Tree : void print(){if(root!=null)root.print(); 4

I Node : void print(){ if(left!=null)left.print(); System.out.println(elem); if(right!=null)right.print(); Prøver vi f.eks. med følgende indsættr Tree t = new Tree(); t.insert(""); t.insert(""); t.insert(""); t.insert("nicolas"); t.insert("jannie"); t.insert("rune"); t.insert("uffe"); t.insert("ann-kristin"); t.print(); Får vi følgende resultat: Ann-Kristin Jannie Nicolas Rune Uffe En anden måde at vi hvad der sker er at lave tostring metoder til klasserne. I Tree : I Node : public String tostring(){if(root!=null)return root.tostring(); return "_"; public String tostring(){ String res="("; if(left!=null)res=res+left.tostring(); res=res+"_"; res=res+","+elem.tostring()+","; if(right!=null)res=res+right.tostring(); res=res+"_"; res=res+")"; return res; Udskriver man træet efter hver indsætt får man da følgende uddata: (_,,_) (_,,(_,,_)) (_,,((_,,_),,_)) (_,,(((_,Nicolas,_),,_),,_)) ((_,Jannie,_),,(((_,Nicolas,_),,_),,_)) ((_,Jannie,_),,(((_,Nicolas,_),,(_,Rune,_)),,_)) ((_,Jannie,_),,(((_,Nicolas,_),,(_,Rune,_)),,(_,Uffe,_))) (((_,Ann-Kristin,_),Jannie,_),,(((_,Nicolas,_),,(_,Rune,_)),,(_,Uffe,_))) 5

Opslag i binært søgetræ Opslag i søgetræet fungere på helt samme måde som indsætt. Man kommer med et objekt og prøver i virkeligheden blot at finde ud af hvor det skulle sættes ind. Hvis der er noget i forvejen returnerer man det ellers returnerer man null. Det giver den følgende kode. I Tree : Comparable opslag(comparable obj){ if(root==null)return null; return root.opslag(obj); I Node : Comparable opslag(comparable obj){ int cmp=obj.compareto(elem); if(cmp<0){ // kig til venstre if(left==null)return null; return left.opslag(obj); if(cmp>0){ // kig til højre if(right==null)return null; return right.opslag(obj); // ellers er cmp == 0 return elem; Diskussion Det smarte ved binære søgetræer er at hastigheden ved indætt og søgninger afhænger af træets højde (dybde) og ikke af hvor mange elementer der er i det. I et træ med højde 10 kan der være ca 1000 elementer, i et træ med højde 20 kan der være ca 1000000 elementer osv. Det går derfor meget hurtigt iforhold til det store antal elementer man kan administrere på denne måde. For at få den fulde fornøj af strukturen er det imidlertid vigtigt at grenene i træet er nogenlunde lige lange. Det sker ikke automatisk - hvis de data man indsætter i forvejen kommer sorteret vil træeet kun vokse i højre side og man vil få et træ som er lige så højt som antallet af elementer. Sker det så ryger hele fordelen. Der findes imidlertid nogle andre måde at indsætte i træet på så man sikre sig mod at det gror skævt. Hvis et træ er lige højdt i alle grene siger man at der er balanceret, og for balancerede træer gælde at søge og indsætt kan klares i logaritmisk tid af antallet af elementer i strukturen. I Java findes binære søgetræer som standard. De erklæres og bruges som følger TreeSet ts = new TreeSet(); Man indsætter i en sådan træstruktur med add metoden. Efter indsætt af elementerne fra før får man følgende resultat: [Ann-Kristin, Jannie,, Nicolas,, Rune,, Uffe] 6