Seminarium inära sökträd Innehåll inära sökträd inära sökträd Definition Implementering lgoritmer Sökning Insättning orttagning Effektivitet alanserade binära sökträd Eempel på vad du ska kunna Förklara begreppet binära sökträd. Förklara hur insättning, sökning och borttagning i ett binärt sökträd går till och kunna implementera sökning och insättning. Förklara begreppet balanserat binärt sökträd (VL-träd) och varför man vill ha balanserade träd. nge tidskompleitet för operationer på binära sökträd, såväl obalanserade som balanserade. Efter detta seminarium ska ni kunna lösa uppgifterna till och med kapitel i övningshäftet. ED0 (Seminarium ST) HT 0 / inära sökträd Definition ED0 (Seminarium ST) HT 0 / Traversering av binära sökträd Ett binärt sökträd är ett binärt träd där följande gäller för varje nod n: lla värden som finns i noder i vänster subträd till n är mindre än värdet som finns i n. lla värden som finns i noder i höger subträd till n är större än värdet som finns i n. Dubbletter tillåts alltså inte. P.g.a. ordningen i ett binärt sökträd gäller att: Genomgång av trädet i inorder besöker noderna i väande ordning. ED0 (Seminarium ST) HT 0 / ED0 (Seminarium ST) HT 0 /
inära sökträd sökning inära sökträd - sökning Eempel Då man söker efter ett element i ett binärt sökträd kan man utnttja ordningen i trädet: örja i roten, jämför med sökt element, om likhet är vi klara. Om är mindre än rotens element: gå till vänster barn annars gå till höger barn. Fortsätt på samma sätt tills vi hittar det sökta, eller tills den nod som står i tur att undersökas är null (misslckad sökning). Sök efter i trädet: örja här: Sök efter i trädet: örja här: Man följer alltså en gren i trädet: Grenen börjar i roten. Man fortsätter tills man hittar det sökta eller till grenen tar slut (misslckad sökning). Klart! Misslckad sökning! ED0 (Seminarium ST) HT 0 / Implementering av binära sökträd Klassen inarsearchtree ED0 (Seminarium ST) HT 0 / tt jämföra elementens ncklar Interfacet omparable<e> public class inarsearchtree<e etends omparable<? super E>> { private Node<E> root; public inarsearchtree() { root = null; public boolean add(e item) {... public E find(e target) {... public boolean contains(object target) {... public boolean remove(e target){......... nästlad klass Node<E> som representerar nod... För att vi ska kunna jämföra elementen med varandra måste klassen som ersätter E implementera interfacet omparable<e>. Då kan vi använda metoden compareto för att jämföra. Vi måste därför ange en begränsning på tpparmetern: public class inarsearchtree<e etends omparable<e>> <E etends omparable<e>> betder att E måste implementera interfacet omparable<e>. Ofta är det för restriktivt att kräva att E implementerar omparable<e>. lternativt kan klassen ärva från en klass för binära träd, som i läroboken. ED0 (Seminarium ST) HT 0 7 / ED0 (Seminarium ST) HT 0 /
Tpparameter med begränsning Varför? super E Eempel: class Person implements omparable<person> {... class Student etends Person {... Vi kan inte skapa ett träd av tpen inasearchtree<student> (trots att Student ärver metoden compareto). Student implementerar inte omparable<student>, utan istället omparable<person>. Vi löser detta genom att kräva att klassen som ersätter E implementera omparable<? super E>.? super E kan utläsas okänd superklass till E (inklusive E) Student implementerar omparable<person> och Person är superklass till Student. Därför uppfller Student kravet för att ersätta E och vi kan skapa träd av tpen inasearchtree<student>. Metoden find public E find (E target) { return find(root, target); private E find(node<e> n, E target) { if (n == null) { return null; int compresult = target.compareto(n.data); if (compresult == 0) { return n.data; else if (compresult < 0) { return find(n.left, target); else { return find(n.right, target); ED0 (Seminarium ST) HT 0 / Implementering av find alternativ Publika metoden find i trädklassen ED0 (Seminarium ST) HT 0 0 / Implementering av find alternativ Privata metoden find i nodklassen I trädklassen: public E find (E target) { if (root == null) { return null; else { return root.find(target); Hjälpmetoden finns på nästa bild. ED0 (Seminarium ST) HT 0 / I nodklassen: private E find (E target) { int compresult = target.compareto(data); if (compresult == 0) { return data; else if (compresult < 0) { if (left!= null) { return left.find(target); else { return null; else { if (right!= null) { return right.find(target); else { return null; ED0 (Seminarium ST) HT 0 /
inära sökträd insättning inära sökträd - insättning Eempel Vid insättning av ntt element ska ordningen i trädet bevaras. Dubbletter får inte förekomma. Sök in i trädet: örja här: Efter insättning: Insättning kan tolkas som misslckad sökning : Vi söker på en gren i trädet. Om vi misslckas med hitta det element som ska sättas in utförs insättningen som ett löv på den plats i trädet där misslckandet konstaterats. Misslckad sökning! Sätt in här: ED0 (Seminarium ST) HT 0 / inära sökträd - insättning Eempel ED0 (Seminarium ST) HT 0 / Metoden add I trädklassen: Sätt in i trädet: örja här: public boolean add(e item) { if (root == null) { root = new Node<E>(item); return true; else { return add(root,item); Dubblett hittas. Insättningen genomför inte. private boolean add(node<e> n, E item) { int compresult = item.compareto(n.data); if (compresult == 0) { return false;... // forts på nästa bild ED0 (Seminarium ST) HT 0 / ED0 (Seminarium ST) HT 0 /
Metoden add, forts Implementering av add jämförelse med boken... // forts från förra bilden if (compresult < 0) { if (n.left == null) { n.left = new Node<E>(item); return true; else { return add(n.left,item); else { if (n.right == null) { n.right = new Node<E>(item); return true; else { return add(n.right,item); I boken används samma teknik i add, men Man fortsätter med rekursiva anrop ända till n är null. I basfallet (n == null) skapas en n nod, som returneras. nropande upplaga kopplar den returnerade noden som barn till sig själv. Eftersom metoden add nu måste returnera en nod, kan den inte också returnera uppgift (boolean) om insättningen lckades eller ej. I stället har man en global variabel i form av ett attribut i klassen (addreturn). Detta är ful design. ttribut ska representera tillstånd hos objektet. Metoden på föregående bilder blir lite längre, men ingen global variabel behövs. ED0 (Seminarium ST) HT 0 7 / inära sökträd borttagning ED0 (Seminarium ST) HT 0 / inära sökträd - borttagning Eempel på enkelt fall - noll barn För att kunna ta bort ett element ur trädet måste vi söka upp det. När vi tar bort det måste vi koppla ihop föräldern med något av barnen. Vid sökningen bör man därför också se till att man får en referens till föräldern. Sammankopplingen sköts på olika sätt beroende på hur många barn som finns till den nod som ska bort: Enklaste fallen är noll eller ett barn. Fallet två barn är lite krångligare. Tag bort ur trädet. örja med att söka efter noden (och föräldern). parent = null act parent act Noden, act, som ska bort är ett löv. Sätt den referens i parent som refererar till act till null. ED0 (Seminarium ST) HT 0 / ED0 (Seminarium ST) HT 0 0 /
inära sökträd - borttagning Eempel på enkelt fall - ett barn inära sökträd - borttagning Eempel - två barn Tag bort ur trädet. örja med att söka efter noden (och föräldern). parent = null act parent act Noden, act, som ska bort har ett barn. Sätt den referens i parent som refererar till act till att referera till act:s barn. Tag bort ur trädet. parent act min Noden, act, som ska bort har två barn: Sök upp minsta noden (min) i act:s högra subträd Fltta data från denna till act Tag bort min ED0 (Seminarium ST) HT 0 / inära sökträd - borttagning Eempel - två barn, forts ED0 (Seminarium ST) HT 0 / inära sökträd borttagning Specialfall Efter flttning av data från min till act: Efter borttagning av min: min Observera att borttagning av min är ett enklare fall eftersom denna nod kan ha högst ett barn (höger). I några av de fall som beskrivits finns det ett alternativ som måste hanteras speciellt: förälder till den nod som skall tas bort saknas, d.v.s. roten tas bort. Fall : roten ska då bli null. Fall : roten ska referera till act:s barn. ED0 (Seminarium ST) HT 0 / ED0 (Seminarium ST) HT 0 /
Eempel på användning av klassen inarsearchtree Implementering av interfacet omparable Klassen Person inarsearchtree<person> bst = new inarsearchtree<person>(); bst.add(new Person("Kajsa", "0-")); //... lägg till fler personer i trädet Person p = bst.find(new Person("Kajsa", null)); public class Person implements omparable<person> { private String name; private String phonenbr;... public int compareto(person ) { return name.compareto(.name); Klassen Person måste implementera omparable<person>. public boolean equals(object obj) { if (obj instanceof Person) { return compareto((person) obj) == 0; else { return false; ED0 (Seminarium ST) HT 0 / inära sökträd tidskompleitet ED0 (Seminarium ST) HT 0 / Samband mellan höjd och antal noder i binära träd För alla binära träd T med n noder gäller för höjden h h n () För att kunna analsera tidskompleitet för operationerna på binära sökträd behöver man känna till vilka samband som råder mellan antal noder och höjd i binära träd. och h log(n + ) () () är enkelt att inse. Trädet får största möjliga höjd om man placerar en nod på varje nivå. Höjden blir då n. E. för n = : ED0 (Seminarium ST) HT 0 7 / ED0 (Seminarium ST) HT 0 /
Samband mellan höjd och antal noder i binära träd, forts inära träd som garanterat har minimal höjd (): På nivå ett finns en nod (roten). På nivå två högst noder, på nivå tre högst nodet etc. llmänt finns det på nivå i högst i noder. Den högsta nivån i ett träd med höjd h är h. = antal noder, n + + +... + i +... + h = h. Vilket ger att h log(n + ) Ett binärt träd är perfekt (eng: perfect binar tree) om alla noder utom löven har två barn och om alla löven befinner sig på samma nivå. Då har trädet formen: Ett binärt träd är komplett (eng: complete binar tree) om alla nivåer utom den högsta är fllda med noder och om noderna på den högsta nivån är samlade längst till vänster. Då har trädet formen: ED0 (Seminarium ST) HT 0 / inära träd som garanterat har minimal höjd ED0 (Seminarium ST) HT 0 0 / inära sökträd tidskompleitet För ett perfekt binärt träd med höjden h gäller att h = log(n + ) där n är antalet noder. För ett komplett binärt träd med höjden h gäller att h < n h eller ekvivalent h < n + h vilket ger log(n + ) h < + log(n + ) d.v.s h log(n + ) Samtliga operationer (sökning, insättning, borttagning) innebär sökning utmed en gren i trädet. I varje nod görs ett konstant arbete (väsentligen en jämförelse). Den längsta grenen i ett träd har h noder, där h är trädets höjd. Värsta fall för samtliga operationer är alltså O(h). Vi har tidigare visat att för alla binära träd med n noder gäller att log(n + ) höjden n För binära sökträd med minimal höjd, O( log n), har operationerna tidskompleitet O( log n) i värsta fall. Men trädets höjd beror på insättnings- och borttagningsordning. ED0 (Seminarium ST) HT 0 / ED0 (Seminarium ST) HT 0 /
inära sökträd - tidskompleitet inära sökträd - tidskompleitet Trädets form beror på insätningsordningen. E: Sätt in,,... 7 (i den ordningen) Ordningen,,,,,, 7 ger: 7 Ordningen,,,, 7,, ger: 7 Den idealiska formen på ett binärt sökträd: lla nivåer, utom möjligen den högsta, har så många noder som är möjligt. Det betder att noderna ligger så nära roten som möjligt. Då blir trädets höjd garanterat O( log n). 7 ED0 (Seminarium ST) HT 0 / inära sökträd - tidskompleitet ED0 (Seminarium ST) HT 0 / alanserade binära sökträd VL-träd Det finns ingen tillräckligt effektiv algoritm för att se till att ett binärt sökträd får den idealiska formen. Trädet behöver inte ha denna form för att garantera att alla operationer blir O( log n) i värsta fall. Det räcker att garantera att höjden är proprtionell mot log n, d.v.s. att h = O( log n). Det finns effektiva algoritmer för att i samband med insättning och borttagning garantera att trädets höjd alltid är O( log n). delson-velsk och Landis gjorde följande definition: alanserat binärt träd Ett binärt träd är balanserat om det för varje nod i trädet gäller att höjdskillnaden mellan dess båda subträd är högst ett. De visade också att I balanserade träd är höjden h. log n. Det finns effektiva algoritmer för att se till att binära sökträd förblir balanserade vid insättningar och borttagningar. ED0 (Seminarium ST) HT 0 / ED0 (Seminarium ST) HT 0 /
alanserade binära sökträd alansering av binära sökträd alanseringsalgoritmerna arbetar med rotationer i trädet: alanserat träd (VL-träd). Trädet är inte perfekt och inte komplett. Obalanserat träd Enkel högerrotation vid = Enkel vänsterrotation vid = ED0 (Seminarium ST) HT 0 7 / alansering av binära sökträd Eempel ED0 (Seminarium ST) HT 0 / alansering av binära sökträd Eempel, forts E: Sätt in ncklarna,,,..., 7 i ett från början tomt VL-träd. Efter enkel vänsterrotation vid : Efter enkel vänsterrotation vid Obalans vid forts... Obalans vid forts... ED0 (Seminarium ST) HT 0 / ED0 (Seminarium ST) HT 0 0 /
alansering av binära sökträd Eempel, forts alansering av binära sökträd Eempel, forts Efter enkel vänsterrotation vid Efter enkel vänsterrotation vid 7 Obalans vid forts... Obalans vid 7 ED0 (Seminarium ST) HT 0 / alansering av binära sökträd Ibland behövs dubbelrotationer: z z D D Höger-vänsterdubbelrotation = Vänster-högerdubbelrotation = ED0 (Seminarium ST) HT 0 / z z D D ED0 (Seminarium ST) HT 0 / alansering av binära sökträd Eempel - dubbelrotationer Efter insättning av och (i den ordningen) i det sista trädet i föregående eempel får man trädet: 7 Det råder nu obalans vid men om man försöker med en enkel vänsterrotation blir det: Detta träd är fortfarande obalanserat! Om man i stället gör en dubbel höger-vänsterrotation vid blir det som på nästa bild. ED0 (Seminarium ST) HT 0 / 7
alansering av binära sökträd Eempel - dubbelrotationer, forts alansering av binära sökträd Obalans vid 7 z Efter dubbel högervänsterrotation vid 7 Obalans måste kunna upptäckas: Man kan ha ett heltalsattribut balance i nodklassen. I balance bokförs höjdskillnaden mellan höger och vänster subträd. I samband med insättning/borttagning ändras ev. höjden av subträd och attributet uppdateras Om höjdskillnaden blir > eller < så åtgärdas det med rotation(er) som i sin tur förändrar höjd och balance hos subträd. Efter eventuella rotation(er) blir absolutbelopppet av balance åter. ED0 (Seminarium ST) HT 0 / alansering av binära sökträd kostnad ED0 (Seminarium ST) HT 0 / alansering av binära sökträd kostnad Man kan visa att: Om obalans uppstår till följd av en insättning i ett tidigare balanserat träd så räcker det med en enkel- eller dubbelrotation för att återställa balansen. Om obalans uppstår till följd av en borttagning ur ett tidigare balanserat träd så kan det behövas en enkel- eller dubbelrotation i varje nod på vägen från den nod där obalans uppstod till roten för att återställa balansen. Höjden förblir O( log n) om man balanserat trädet vid varje förändring. En enskild rotation kostar bara O(). Kostnaden för balansering i samband med en insättning eller borttagning är O( log n). Insättning kräver visserligen bara en rotation, men balansinformationen måste uppdateras i noder på vägen från insättningsplatsen till roten. Om ett binärt sökträd hålls balanserat kommer sökning, insättning och borttagning därmed att kosta O( log n) i värsta fall. ED0 (Seminarium ST) HT 0 7 / ED0 (Seminarium ST) HT 0 /