Föreläsning Innehåll inära sökträd algoritmer för sökning, insättning och borttagning implementering effektivitet balanserade binära sökträd, VL-träd Jämföra objekt interfacet omparable Interfacet omparator Datastrukturer som passar för sökning ntag att vi i ett program ska hantera ett stort antal element av något slag. Det ska gå snabbt att sätta in ett element ta bort ett element söka efter ett visst element Vilken/vilka datastrukturer passar bra för detta? vektor, enkellänkad lista insättning snabb O() sökning (linjärsökning) och borttagning långsamma O(n) sorterad vektor sökning (binärsökning) snabb O(logn) insättning och borttagning långsamma O(n) Det finns datastrukturer som passar bättre för detta: inära sökträd Hashtabeller Datavetenskap (LTH) Föreläsning HT / 7 inära sökträd Definition Datavetenskap (LTH) Föreläsning HT / 7 Inordertraversering 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. Genomgång av trädet i inorder besöker noderna i väande ordning. Eempel: En inordertraversering av trädet i figuren ger noderna i ordningen,,,,, Datavetenskap (LTH) Föreläsning HT / 7 Datavetenskap (LTH) Föreläsning HT / 7
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! Datavetenskap (LTH) Föreläsning HT / 7 Diskutera Datavetenskap (LTH) Föreläsning HT / 7 inära sökträd - insättning Eempel Hur går insättning i ett binärt sökträd till? Var i trädet ska sättas in? Var i trädet ska 7 sättas in? Sätt in i trädet: örja här: Efter insättning: Misslckad sökning! Sätt in här. Datavetenskap (LTH) Föreläsning HT 7 / 7 Datavetenskap (LTH) Föreläsning HT / 7
inära sökträd - insättning Eempel inära sökträd insättning Sammanfattning Sätt in i trädet: örja här: Vid insättning av ntt element ska ordningen i trädet bevaras. Dubbletter får inte förekomma. Dubblett hittas. Insättningen genomförs inte. 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. Datavetenskap (LTH) Föreläsning HT / 7 inära sökträd borttagning Datavetenskap (LTH) Föreläsning HT / 7 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 behöver man därför hålla reda på 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. Datavetenskap (LTH) Föreläsning HT / 7 Datavetenskap (LTH) Föreläsning HT / 7
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 Datavetenskap (LTH) Föreläsning HT / 7 inära sökträd - borttagning Eempel - två barn, forts Datavetenskap (LTH) Föreläsning HT / 7 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. Datavetenskap (LTH) Föreläsning HT / 7 Datavetenskap (LTH) Föreläsning HT / 7
Implementering av binära sökträd Klassen inarsearchtree Sökning i binärt sökträd pseudokod Eempel på hur en klass som representerar ett binärt sökträd kan se ut: public class inarsearchtree<e> { private Node<E> root; public inarsearchtree() { root = null; public boolean add(e e) {... public E find(e ) {... public boolean remove(e ){...... // nästlad klass Node<E> med attributen data, left och right // som representerar en nod... E find(node, ) { om node == null) return null annars om är lika med node.data return node.data; annars om är mindre än node.data return find(node.left, ) // sök i vänster subträd annars return find(node.right, ) // sök i höger subträd nropas find(root, ) Datavetenskap (LTH) Föreläsning HT 7 / 7 Diskutera Datavetenskap (LTH) Föreläsning HT / 7 Metoden find public E find(e ) { return find(root, ); Hur ska jämförelserna mellan två element i trädet gå till? om är lika med node.data om är mindre än node.data private E find(node<e> n, E ) { if (n == null) { return null; int compresult = ((omparable<e>) ).compareto(n.data); if (compresult == ) { return n.data; else if (compresult < ) { return find(n.left, ); else { return find(n.right, ); Datavetenskap (LTH) Föreläsning HT / 7 Datavetenskap (LTH) Föreläsning HT / 7
Interfacet omparable Repetition Kommentarer Metoden compareto i interfacet omparable används inuti add, find och remove för att jämföra två element. public interface omparable<t> { /** * ompares this object with the specified object for order. * Returns a negative integer, zero, or a positive integer as * this object is less than, equal to, or greater than the * specified object. */ public int compareto(t ); Klassen som ersätter E måste implementera omparable<e>. nnars genereras lassasteception när find eekveras. För att anropet av compareto ska fungera måste vi tpkonvertera till omparable<e>:... ((omparable<e>) ).compareto(node.data)... En annan lösning är att via en konstruktor förse klassen inarsearchtree med ett komparator-objekt comp och använda metoden compare för att jämföra:... comp.compare(, node.data)... Datavetenskap (LTH) Föreläsning HT / 7 Eempel på användning av klassen inarsearchtree Datavetenskap (LTH) Föreläsning HT / 7 Implementering av interfacet omparable Klassen Person // Skapa ett träd sorterat efter idnummer inarsearchtree<person> bst = new inarsearchtree<person>(); bst.add(new Person("Fili", )); bst.add(new Person("alin", ));... // sök efter personen med idnummer Person p = bst.find(new Person(null, ); Klassen Person måste implementera omparable<person>. Observera att man måste skapa ett Person-objekt för att kunna söka efter en person i trädet. Detta objekt måste få korrekta värden på de attribut som används för jämförelser i compareto. public class Person implements omparable<person> { private String name; private int id;... public int compareto(person other) { return Integer.compare(id, other.id); omparable är ett generiskt interface. I eemplet är Person tpargument. Observera att parametern i compareto därför har tpen Person. Datavetenskap (LTH) Föreläsning HT / 7 Datavetenskap (LTH) Föreläsning HT / 7
Interfacet omparator Vi ska se till att det finns ett alternativ till compareto för att jämföra element inuti trädklassen. Interfacet omparator ger oss möjlighet att jämföra objekt av en klass på flera olika sätt. public interface omparator<t> { /** * ompares its two arguments for order. * Returns a negative integer, zero, or a positive * integer as the first argument is less than, * equal to, or greater than the second. */ int compare(t e, T e); Datavetenskap (LTH) Föreläsning HT / 7 Metod för att välja mellan compareto och compare privat metod i klassen inarsearchtree Konstruktor med parameter av tpen omparator Klassen inarsearchtree public class inarsearchtree<e> { private Node<E> root; private omparator<e> comp; /** Skapar ett tomt binärt sökträd. Elementen förutsätts vara av en klass som implementerar omparable<e>. */ public inarsearchtree() { root = null; comp = null; /** Skapar ett tomt binärt sökträd. Elementen jämförs med komparatorn comp. */ public inarsearchtree(omparator<e> comp) { root = null; this.comp = comp; Datavetenskap... (LTH) Föreläsning HT / 7 Metoden find nvändning av metoden compareelements... private int compareelements(e e, E e) { if (comp == null) { return ((omparable<e>) e).compareto(e); else { return comp.compare(e, e);... public E find (E target) { return find(root, target); private E find(node<e> n, E target) { if (n == null) { return null; int compresult = compareelements(target, n.data); if (compresult == ) { return n.data; else if (compresult < ) { return find(n.left, target); else { return find(n.right, target); // ntt Datavetenskap (LTH) Föreläsning HT 7 / 7 Datavetenskap (LTH) Föreläsning HT / 7
Två konstruktorer Skapa komparator-objekt med lambdauttrck Nu har klassen två konstruktorer: public inarsearchtree(); public inarsearchtree(omparator<? super E> c); nvänds den första konstruktorn, förutsätts elementen implementera omparable annars genereras lassasteception. Inuti trädklassen används metoden compareto för att jämföra två objekt. Den andra konstruktorn har en parameter av tpen omparator. Vid anrop skickar man med en referens till ett objekt av en klass som implementerar interfacet omparator. nvänds denna kommer jämförelser att utföras med hjälp av komparatorns metod compare. // Skapa ett träd sorterat efter namn inarsearchtree<person> bst = new inarsearchtree<person>( (p, p) -> p.getname().compareto(p.getname()) ); bst.add(new Person("Fili", )); bst.add(new Person("alin", ));... // sök efter personen med namnet alin Person p = bst.find(new Person(alin, -); Interfacet omparator<e> är ett funktionellt interface, d.v.s. den har bara en abstrakt metod. I sådana fall kan man använda lambdauttrck istället för att skriva en klass som implementerar interfacet skapa ett objekt av denna klass och skicka med en referens till ett sådant objekt som argument. Datavetenskap (LTH) Föreläsning HT / 7 Skapa komparator-objekt längre version Datavetenskap (LTH) Föreläsning HT / 7 Vad betder? super E Överkurs Skriv en komparatorklass som implementerar interfacet omparator: public class Nameomparator implements omparator<person> { public int compare(person p, Person p) { return p.getname().compareto(p.getname()); Skapa ett objekt av komparatorklassen och skicka med som argument till konstruktorn i trädklassen: inarsearchtree<person> bst = new inarsearchtree<person>(new Nameomparator()); Datavetenskap (LTH) Föreläsning HT / 7? super E kan utläsas okänd superklass till E (inklusive E) Tpen omparator<? super E> bör användas i trädklassen istället för omparator<e>. Förklaring: ntag att vi har följande klasser: class Person {... class Student etends Person {... class Nameomparator implements omparator<person> {... Om omparator<e> används inuti trädklassen kan vi inte skriva: inarsearchtree<student> bst = new inarsearchtree<student>(new Nameomparator()); Det finns ingen klass som implementerar omparator<student>. Istället lättar vi på på kravet och kräver att komparatorklassen istället ska implementera omparator<? super E>. Då kan vi skapa studentträdet eftersom Person är superklass till Student. Datavetenskap (LTH) Föreläsning HT / 7
Diskutera inära sökträd tidskompleitet En traversering genom alla noderna i ett träd med n noder har tidskompleiteten O(n). Varje nod besöks en gång. Vad påverkar effektiviteten för operationerna sökning, insättning och borttagning? Vad får dessa metoder för tidskompleitet? Operationerna sökning, insättning och 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 vill uttrcka tidskompleiteten som en funktion av antal noder, n. Vi måste alltså känna till sambandet mellan trädet höjd och antal noder. Datavetenskap (LTH) Föreläsning HT / 7 Samband mellan höjd och antal noder i binära träd Datavetenskap (LTH) Föreläsning HT / 7 Samband mellan höjd och antal noder i binära träd, forts För alla binära träd T med n noder gäller för höjden h och h n () 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 = : (): 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 = h. Vilket ger att h log(n + ) Här har vi använt formeln för geometrisk summa: + a + a +... + a k = ak+ a Datavetenskap (LTH) Föreläsning HT / 7 Datavetenskap (LTH) Föreläsning HT / 7
inära sökträd tidskompleitet Diskutera 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). Sätt in,,... 7 (i den ordningen) Sätt in,,,,,, 7: Sätt in,,,, 7,, : Vi har tidigare visat att för alla binära träd med n noder gäller att log(n + ) höjden n De tre operationerna har tidskompleitet O(n) i värsta fall och O( log n) i bästa fall. Vilken insättningsordning ger bästa respektive sämsta formen på trädet? Datavetenskap (LTH) Föreläsning HT 7 / 7 inära sökträd tidskompleitet, forts Datavetenskap (LTH) Föreläsning HT / 7 inära sökträd med minimal höjd Trädets höjd påverkas av insättningar och borttagningar. I värsta fall består trädet av en enda gren och värstafallstiden för sökning, insättning och borttagning blir O(n). Vid slumpmässiga insättningar och borttagningar blir tidskompleiteten i medelfall O( log n). Vi ska stra se hur man kan hålla trädet balanserat och även få en värstafallstid på O( log n). 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). Datavetenskap (LTH) Föreläsning HT / 7 Datavetenskap (LTH) Föreläsning HT / 7
Eempel på binära träd med minimal höjd inära sökträd - tidskompleitet 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: 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). Datavetenskap (LTH) Föreläsning HT / 7 alanserade binära sökträd VL-träd Datavetenskap (LTH) Föreläsning HT / 7 alanserade binära sökträd Georg delson-velsk and Evgenii 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. alanserat träd Obalanserat träd Datavetenskap (LTH) Föreläsning HT / 7 Datavetenskap (LTH) Föreläsning HT / 7
alanserade binära sökträd Diskutera balans = hr hl hr = höger subträds höjd hl = vänster subträds höjd Vad händer med trädets balansering om man lägger till? Hur kan man rätta till det? alanserat träd Obalanserat träd Datavetenskap (LTH) Föreläsning HT / 7 alansering av binära sökträd alanseringsalgoritmerna arbetar med rotationer i trädet: Datavetenskap (LTH) Föreläsning HT / 7 alansering av binära sökträd Eempel Obalanserat vid : Efter en enkel högerrotation: Enkel högerrotation vid = Enkel vänsterrotation vid = Datavetenskap (LTH) Föreläsning HT 7 / 7 Datavetenskap (LTH) Föreläsning HT / 7
alansering av binära sökträd Ibland behövs dubbelrotationer: z D Höger-vänsterdubbelrotation = z D alansering av binära sökträd Eempel - dubbelrotationer Efter insättning av 7 får man trädet: z D Vänster-högerdubbelrotation = z D 7 Det råder nu obalans vid men om man försöker med en enkel högerrotation blir det: 7 Detta träd är fortfarande obalanserat! Istället måste man göra en dubbel vänsterhögerrotation (se nästa bild). Datavetenskap (LTH) Föreläsning HT / 7 alansering av binära sökträd Eempel - dubbelrotationer Datavetenskap (LTH) Föreläsning HT / 7 alansering av binära sökträd Obalanserat vid : 7 Efter en vänster-högerrotation: 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 absolutbeloppet av balance åter. Datavetenskap (LTH) Föreläsning HT / 7 Datavetenskap (LTH) Föreläsning HT / 7
alansering av binära sökträd kostnad 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). 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. Datavetenskap (LTH) Föreläsning HT / 7 Eempel på vad du ska kunna Datavetenskap (LTH) Föreläsning HT / 7 Datorlaboration inära sökträd 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. Känna till och kunna implementera interfacet omparable. Förklara begreppet balanserat binärt sökträd och varför man vill ha balanserade träd. Förklara begreppet VL-träd. nge tidskompleitet för operationer på binära sökträd. Känna till och kunna implementera interfacet omparator. Kunna skicka med lambdauttrck som argument till parametrar av tpen omparator. Implementera en egen generisk klass för binära sökträd. Tips: I flera fall blir det en (kort) publik metod som anropar en privat rekursiv metod. I en av metoderna ska ett ntt träd bggas upp från värden i en vektor. Hämta inspiration från den rekursiva algoritmen för binärsökning. Rita för att förstå vad som händer i programmet! Innehåll: binära sökträd, rekursion, länkad struktur. Datavetenskap (LTH) Föreläsning HT / 7 Datavetenskap (LTH) Föreläsning HT / 7
Datorlaboration, forts Insättning i binära sökträd Ncklarna i vänster subträd < roten < ncklarna i höger subträd Dubbletter är ej tillåtna. Na noder sätts alltid in som löv. Insättning börjar med en (förhoppningsvis) misslckad sökning. Eempel: Sätt in. örja här: Misslckad sökning! Sätt in här. Datavetenskap (LTH) Föreläsning HT 7 / 7