F4: Mer om OU1, OU2, listor och träd. Carl Nettelblad

F4: Mer om OU1, OU2, listor och träd Carl Nettelblad 2018-04-17

Kodstil Glöm inte bra Javadoc Ge rimliga namn Se till att koden är rätt indenterad Editorn kan hjälpa dig Undvik Kopierad kod Mycket långa rader

Lägga till i en stack Uppgiftstexten talade om Se till att tiden för metoderna push och pop är oberoende av stackens storlek! Vad kan gå fel? Spelar det roll hur man lägger till elementet?

Algoritmanalys rekursion Hur lång tid en rekursion tar beror på Hur svårt det är att dela upp problemet Antalet delproblem Delproblemens storlek Arbetet för att kombinera dem Eftersom det är rekursivt sker detta på varje nivå

Några exempel Vi löser problem av storlek n, varje problem delas upp i D delproblem av storlek S, arbetet att dela upp och foga samman blir F. Ger total tid enligt nedan D S F Total tid Exempel 1 n-1 O(1) Θ(n) Linjär sökning (largest) 1 n-1 Θ(n) Θ(n 2 ) Enkla sorteringsmetoder 1 n/2 O(1) Θ(log n) Effektiv rekursiv beräkning x n, binär sökning 2 n-1 O(1) Θ(2 n ) Brickleken 2 n/2 Θ(n) Θ(n logn) Mergesort

Omöjliga problem Kortaste resvägen för att besöka alla städerna Ett lösningssätt: prova alla rekursivt Håll reda på vilka som redan är besökta Basfall: alla besökta Fördjupning: testa alla obesökta som nästa Sammanfogning: hitta minsta

Hur lång körtid? Antalet rekursionssteg blir att lista alla ordningar på listan med städer För n städer blir det n! Växer ungefär exponentiellt D = n 1, F = n 1, S = n 1 för att använda samma notation som innan

Hur lång körtid? Men visst måste det gå snabbare än att prova alla? Ofta Naturliga kartor har inte maskhål Men det går att bevisa att detta och andra problem är NP-svåra Det finns ingen lösning som hittar bästa vägen för en godtycklig version av problemet i polynomisk tid Väldigt annorlunda än Fibonacci (ungefär:) Körtid växer exponentiellt med problemstorlek

Hur lång körtid? Bästa rutten för en budfirma 20 paket till olika platser Om vi kan testa en ordning i vår sökning på 1 ns 1 miljard per sekund 20! är ungefär 2,5 triljoner Ungefär 77 år för att hitta lösningen Annat viktigt problem som tar lång tid Faktorisera tal med stora primfaktorer

Räkna millisekunder Räkna om millisekunder till genomsnittsår double time = c * pow(1.618, 100) / (1000 * 3600 * 24 * 365); Varför är detta fel? (Förutom att vi struntar i skottår.) double time = c * pow(1.618, 100) / (1000. * 3600 * 24 * 365);

OU2 igen Recursive descent Varje element i syntaxdiagram motsvaras av en metod Metoderna läser från strömmen från vänster till höger Varje uttryck ett antal termer förenade med + -, som i sin tur består av faktorer förenade med * / Fel ska rapporteras

Recursive descent Skriv regler från låg till hög prioritet Anropa inre regler En högprioritetsregel slutar tolka när uttrycket inte matchar Vanlig typ av syntaxfel att missa att läsa ända till strömslut a * 3 ^ 4 kommer att ge denna typ av fel i vår kalkylator Det fel som rapporteras är expected EOL, men det verkliga felet är ^ not recognized

Syntaxdiagram statement Tom rad Specialkommandon quit, vars, file Ett tilldelningsuttryck

Syntaxdiagram assignment Ett uttryck Potentiellt följt av ett likhetstecken Syntaxfel om det inte kommer ett ord efter likhetstecknet 5 = 5 funkar inte 5 = 3 funkar inte heller 5 = (x) funkar inte heller

Syntaxdiagram expression En term Potentiellt följt av + eller och fler termer + och kan blandas 5 + 3 2 x + 7

Syntaxdiagram term En faktor Potentiellt följt av * eller / och fler faktorer * och / kan blandas x * 3 / 2 / (y + 5) * sin(3)

Syntaxdiagram factor Ett primärt element En uppdelning som vi inte hade på föreläsningen förra veckan Förbereder för OU5

Syntaxdiagram primary Parenteser (med assignment inuti) Funktionsanrop (med assignment som parameter) Ett tal Unärt minus -x, -sin(5), -(3), -4 Variabel Syntaxfel Högerparentes saknas efter assignment (5 + 3 Ingen parentes efter funktionsnamn Falla ut helt och hållet 5 + sin x Texten efter + ska tolkas som en term, som blir en factor, som blir en primary

Beräkningsfel Variabler som inte finns än 5 + x fungerar inte 5 = x 5 + x fungerar

Kodskelettet Få in rapportering av fel i Calculator Implementera alla delar av syntaxdiagrammen, inklusive att fel kastas Se till att hela er kod har rimlig kodstil och att ni begriper den!

Listor och träd Grafer Noder och kanter Listor och träd de enklaste Utgångspunkten för OU3

Linjär lista Varje element har en föregångare och efterföljare Listan som helhet har en början och ett slut Kö, stack

Arraybaserade listor Elementen har inte bara efterföljare och föregående, utan index Kan nå vilket element som helst snabbt, O(1) tid Lägga till/ta bort element dyrt Det gäller oavsett om du skriver det själv eller använder ArrayList Problem om man exempelvis vill hantera en kö Eller en lång deltagarlista med personer där personer kan komma och gå i olika ordning

Länkade listor I stället för index Låt varje element peka på sin efterföljare Fördel: Lätt att förändra listan. Om man har föregående element kan en ny efterföljare läggas till i tid O(1). Kan användas för att ta bort, lägga till, flytta element. Nackdel: Svårt att hitta element i viss position (O(n)). Långsammare att stega mellan element (O(1), men tar klart längre tid). Använd inte länkade listor om du inte specifikt vill åt fördelarna.

Klasser för länkade listor Precis som ArrayList finns LinkedList i Java Men nu ska vi inte använda den! Vi ska skriva vår egen klass Övning för att själv kunna skapa mer avancerade grafer och datastrukturer Övning i rekursivt tänkande En listan kan vara Tom Eller ett element, som i sig pekar på en lista

Exempel En klass List För länkade listor med heltal i listnoderna Listan sorterad (bra i vissa fall) Samma värde får bara förekomma en gång Annorlunda än i uppgiften Vår klass blir en representation av mängder med heltal Anmärkning: De flesta tekniker vi diskuterar är generella, gäller mer än bara heltal.

Enkellänkad lista Varje element pekar på sin efterföljare Inte föregångare! Hitta föregångare lika dyrt som att hitta visst index Varje element representeras med klassen Node Rekursiv definition, en Node har en referens till en (annan?) Node class Node { int data; Node next; }

Vad är en lista? Node-instansen för första elementet definierar hela listan Normalt sett brukar man ändå ha en yttre ägarklass Metoder för att hantera listan Representera tomma listor

Klassen List public class List { private Node first; private Node last; // Optional

Klassen List public class List { private static class Node { int data; Node next; Inre klass. Vilken skillnad gör static? } Node(int d, Node n) { data = d; next = n; } private Node first; private Node last; // Optional...

tostring public String tostring() { } return "[" + tostring(first) + "]"; private static String tostring(node n) { if (n==null) { return ""; } else { return n.data + " " + tostring(n.next); } } Varför static? Vanligt mönster med hjälpmetod som vandrar rekursivt genom elementen Skulle kunna skrivas iterativt också, ibland svårare

Stoppa in nya element Hitta elementet före önskad position Elementet som ska få ny efterföljare

Stoppa in nya element, iterativt public void additer(int x) { if (first == null x < first.data) { first = new Node(x, first); // New start of list } else { Node n = first; while (n.next!=null && x > n.next.data) { n = n.next; } if ( n.next==null x < n.next.data) { n.next = new Node(x, n.next); } } }

Stoppa in nya element, rekursivt public void add(int k) { } first = add(k, first); // Return new successor to previous node, // if current next node is n private static Node add(int k, Node n) { if (n==null k<n.data) { return new Node(k, n); } else if (k>n.data) { n.next = add(k, n.next); } return n; }

Kopiera listor Vill ha en kopia av en hel lista Rimligen för att vi ska kunna redigera kopian Eller originalet Försök 1: public List copy() { List result = new List(); result.first = this.first; } return result;

Kopiera lista public List copy() { } List result = new List(); for (Node n=first; n!=null; n = n.next) { result.add(n.data); } return result; Nytt försök Åtminstone korrekt resultat Men kanske inte idealiskt? (Tidsåtgång?)

Kopiera lista Rekursiv hjälpmetod för nästa efterföljare Fundera över: Hur skriva samma algoritm iterativt? public List copy() { } return new List(copy(first)); // Private constructor private static Node copy(node n) { } if (n == null) { return null; } else { } return new Node(n.data, copy(n.next));

Andra länkade listor Enkellänkad lista enkel En extra referens för varje element Och elementklassen Algoritmerna enkla Men svårt att gå bakåt från element, gå till slutet

Dubbellänkat Kan nå både efterföljare och föregångare till ett element i O(1) tid Mer minne, fler referenser att hålla reda på i algoritmerna Cirkulärt Nå både första och sista i O(1) tid Listan håller reda på sista, sistas efterföljare är första Algoritmer måste ändras för att inte gå runt oändligt

Dubbellänkad cirkulär Många operationer möjliga, men alla algoritmer blir mer komplicerade och lagringen kräver mer minne Enkellänkad kan ofta vara enklast och effektivast Ibland med tillägget att listobjektet också håller reda på direktpekare till sistaelementet, och/eller totala antalet element

Hjälpmetoder Publika metoder finns för att ge ett tydligt kontrakt till omvärlden Så här använder du den här klassen Hjälpmetoderna finns för att ge dig en tydlig struktur inne i klassen Kan göra saker som är förbjudna utifrån Kan ta andra parametrar och returnera andra värden än de publika metoderna Klassmetoder (static) om all information finns i parametrarna och returvärdet

Exempel Hjälpmetoden tar en parameter om vad den ska jobba på private static String tostring(node n) för public String tostring() Annan returtyp private static Node add(int k, Node n) för public void add(int k) private static Node copy(node n) för public List copy()

Hjälpmetoder med void som returtyp Hjälpmetoden kan ta in ett objekt som parameter och förändra det objektet Behöver inte returnera något för att kommunicera med omvärlden public ArrayList<Integer> toarraylist() { ArrayList<Integer> result = new ArrayList<Integer(); toarraylist(first, result); return result; } private static void toarraylist(node n, ArrayList<Integer> al) { if (n!= null) { al.add(n.data); toarraylist(n.next, al); } }

Hjälpmetoder static gör det tydligt att instansen inte påverkas på andra sätt än genom parametrarna Hjälpmetod med samma namn som den publika metoden gör det tydligt vem man hjälper Men det är inte säkert att ovanstående gäller för alla hjälpmetoder Viktigaste är att undvika enskilda väldigt krångliga metoder, eller kopierad kod Välj vilka hjälpmetoder du har, med vilken signatur (static? parametrar? returtyp? namn?) för att ge maximal nytta och tydlighet

LinkedList<E> i Java Dubbellänkad lista av element med typ E Implementerar samma metoder som ArrayList<E> Men inte samma tidegenskaper Några metoder: boolean add(e e) void addfirst(e e) void clear() boolean contains(object o) E get(int index) E getfirst() E getlast() E remove(int index) E removefirst() E removelast() E set(int index, E e) int size()

Träd Ett (rotat) träd är en mängd noder där En speciell nod kallas rot Övriga noder delas in i m disjunkta delmängder som i sin tur är rotade träd Rekursiv definition! Inga cykler Tydlig riktning på relation mellan noder

Lite terminologi

Binära träd Ett binärt träd är en mängd noder som antingen är tom eller som består av tre olika delmängder Exakt en nod: roten Vänster delträd Höger delträd Observera att vänster delträd kan vara tomt Höger delträd något annat än bara andra barnet

Operationer på träd Orientering, vandring mellan noderna Traversering, besök alla noder Sökning efter nodinnehåll eller position Inlägg/uttag av noder Sammanfogning av flera träd Mätning av höjd, bredd, antal noder, stiglängd, balans

Traversering av träd Besök alla noder i ett (del)träd Naturligt rekursiv beskrivning Men vilken ordning ska vi gå i? Spelar det någon roll?

Preorder 1. Besök roten 2. Besök barnträden i preorder (äldsta först) Resultat: e b a d c n g f k p y

Postorder 1. Besök barnträden i postorder (äldsta först) 2. Besök roten Resultat: a c d b f k g y p n e

Inorder (binära träd) 1. Besök vänster delträd inorder 2. Besök roten 3. Besök höger delträd inorder Resultat: a b c d e f g k n p y

Representera binära träd i kod Precis som med listor skapar vi nodobjekt Som refererar till andra nodobjekt class Node { } int data; Node parent; Node left; Node right;... Förälderpekaren är ofta onödig, jämför enkellänkad/dubbellänkad lista.

Exempel: BinarySearchTree En klass som lagrar textsträngar som data i ett binärt träd Trädet är ett binärt sökträd, med följande regel för alla noder Varje nyckel (unik sträng) finns alltså högst en gång Praktisk struktur för sökning, inläggning och urtag Men inte oproblematisk

Nodrepresentation private static class Node { private String value; private Node left, right; } private Node(String value, Node left, Node right) { this.value = value; this.left = left; this.right = right; }

Placering av klassen public class BinarySearchTree { private static class Node {... } private Node root; public BinarySearchTree() { root = null; }

tostring public String tostring() { return tostring(root); } private static String tostring(node r) { if (r == null) { return ""; } else { return tostring(r.left) + " " + r.value + " " + tostring(r.right); } } Vilken typ av traversering är detta? Preorder, postorder, inorder?

Lämna till hjälpmetod public void add(string value) { root = add(root, value); } Lägga till element

Lägga till element private static Node add(node r, String value) { } if (r==null) { } return new Node(value,null,null); int compare = value.compareto(r.value); if (compare<0) { r.left = add(r.left, value); } else if (compare>0) { } r.right = add(r.right, value); return r; Fortsätt tills underträd saknas och lägg in ny nod där med värdet Låt jämförelse styra önskat värde Eller stanna om befintligt element har samma värde Jämför med likheterna i List

Egenskaper hos binära träd Ett binärt träd med k fyllda nivåer innehåller n noder n = 1 + 2 + 4 + + 2 k 1 = 2 k -1 k = log 2 (n + 1) log 2 n I ett sådant träd blir arbetet för Sökning O log n Inlägg O log n Uttag O log n

Sämsta möjliga träd I ett sådant träd blir arbetet för Sökning O n Inlägg O n Uttag O n Trädet en linjär lista Algoritmerna blir i praktiken som algoritmerna för enkellänkad

Vad händer för mitt träd? Vad gäller i genomsnitt? Vad är genomsnitt? I genomsnitt i ett genomsnittligt träd? Tre mått som påverkar trädets prestanda: Höjd ger rekursionsdjup i värsta möjliga fall Värsta möjliga höjd lika med antalet element Intern väglängd: för lyckad sökning Extern väglängd: för misslyckad sökning

Intern väglängd Intern väglängd (ipl, eller bara i) kan definieras som summan av nivån för alla noder Roten har nivå 1, rotens barn nivå 2, Exempel: i = 1 + 2 * 2 + 4 * 3 + 4 * 4 = 33 Att hitta en lagrad nyckel tar då i genomsnitt i n = 33 11 = 3 steg

Extern väglängd Extern väglängd (EPL, eller bara E) tar med externa noder dessutom Den externa väglängden definieras som summan av de externa nodernas nivåer (4 * 4 + 8 * 5 = 56 för exemplets 12 externa noder) Varje sökning efter en nyckel som inte finns slutar i en extern nod. Eftersom antalet externa noder är n + 1 blir det genomsnittliga antalet försök för misslyckad sökning E/(n + 1) Extra: Bevisa att antalet externa noder är n + 1 och att E = i + 2n + 1

Iläggningsordning Hur ett binärt träd växer beror på i vilken ordning noderna läggs i Praktiska implementationer kan ibland också balansera om trädet AVL-träd, rödsvarta träd En definition på hur bra trädet är blir hur välordnat det blir i medeltal över alla möjliga iläggningsordningar Den interna väglängden för alla träd som bildas om man lägger in alla n! permutationer av n nycklar blir 1,38 n log 2 n + O n I ett slumpmässigt träd tar då sökning O(log n) operationer

Binära sökträd i Java TreeSet<E>, TreeMap<K,V> är sådana ombalanserande binära träd. De garanterar O(log n) för inlägg, sökning och urtag för varje specifikt träd.

Alla binära träd är inte sökträd

Alla binära träd är inte sökträd Aritmetiska uttrycket 1 * (2 3) + (4 + 5)/6 Trädet styr evalueringsordning, inga parenteser Värdet beräknas genom att rekursivt: Beräkna värdet av vänster träd Beräkna värdet av höger träd Utföra operationen på de två beräknade värdena

OU3 Utgå från beskrivningen av enkellänkade listor och binära träd Fundera över vilka rekursiva hjälpmetoder som blir nyttiga Fundera över tidskomplexitet Se till att skriva egna testfall för BST, lita inte bara på automattesterna