EN SNABBIS OM DoA. Programmeringsmetodik med Java, HT-07 Kognitionsvetenskapliga programmet. Pedher Johansson 7 januari 2008

Transkript

1 EN SNABBIS OM DoA Programmeringsmetodik med Java, HT-07 Kognitionsvetenskapliga programmet Pedher Johansson 7 januari 2008 UMEÅ UNIVERSITY DEPARTMENT OF COMPUTING SCIENCE SE UMEÅ SWEDEN

2

3 Innehållsförteckning Kapitel 1 Inledning 4 Kapitel 2 Linjära strukturer Strukturer med statisk storlek Länkade strukturer Listor Stackar Köer 14 Kapitel 3 Algoritmer Komplexitet 17 Kapitel 4 Sortering Bubble sort Merge sort Quick sort Vad skall man välja? 23 Kapitel 5 Grenade strukturer Träd Binära träd Grafer Sökordning 29 Kapitel 6 Övriga strukturer Mängd 31 3

4 Kapitel 1 Inledning De vanliga så kallade primitiva datatyperna i Java utgör en grupp av enkla byggstenar när man programmerar. Dessa fungerar i stort sett likadant i Java som i andra och tidigare språk såsom C och Fortran. Vi har datatyper för heltal, flyttal och tecken. Primitiva datatyper räcker långt när vi vill representera något i ett program, t.ex ett antal av något eller andel av något. När man vill representera något lite mer sammansatt i ett program, t.ex en serie tal eller personuppgifter om någon kan man givetvis använda sig av de primitiva datatyperna, men det blir genast mer besvärligt. Man behöver ofta flera olika variabler av samma eller olika datatyper och namngivningen blir svår och det blir fort många variabler att hålla reda på. De primitiva datatyperna har ett värde samt ett antal fördefinierade operationer man kan utföra på dem. För flyttal kan man t.ex. addera två flyttal med varandra och därmed få ett nytt flyttal. Vi är vana att arbeta med dessa datatyper men vi funderar kanske inte så noga på exakt hur talet är representerat i minnet eller hur additionen går till, vilket också är olika mellan olika maskintyper. Med abstrakta datatyper är det precis detta tankesätt man vill ådstakomma. Man vill få en ny datatyp som kan användas för att representera något och ha väl definierade operationer man kan utföra på datatypen. Vad som däremot inte är så intressant är exakt hur operationen utförs eller hur data representeras internt inom datatypen. Det fina med ett objektorienterat språk är att man vill uppnå samma mål som med en abstrakt datatyp, men inte enbart för datatypen utan för hela programmet. Hur något lagras i minnet eller hur operationer utförs är inte intressant, däremot är operationerna väl definierade och man vet vad som blir resultatet av en viss operation. Ett objektorienterat språksomjavalämpar sig därför utmärkt när man vill jobba med abstrakta datatyper. Vi kommer att gå igenom några vanligt förekommande abstrakta datatyper och dess användning och egenskaper. Dessutom exempel på hur dessa kan implementeras i Java. Andra koncept som behandlas här är algoritmer, sortering och komplexitet. 4

5 Kapitel 2 Linjära strukturer Vid programmering är det vanligt att man vill hantera en sekvens eller samling av värden av samma datatyp enligt en viss ordning. Ett exempel är teckensträngar som består av en sekvens av tecken som tillsammans utgör ett ord eller mening. Vill man analysera uttal kanske man har en digital representation av en ljudsnutt som en lång sekvens av flyttal. Sekvenser behöver inte bara vara av primitiva datatyper utan kan ju också vara ett antal personuppgifter lagrade som objekt. 2.1 Strukturer med statisk storlek När något har statisk storlek kan man inte ändra storleken på dem efter det att de är skapade. Redan från början har de alltså en fix kapacitet, d.v.s. ett fixt antal element kan lagras Arrayer Den enklaste formen är det som ofta benämns arrayer efter det engelska namnet. Med det menas att man allokerar en sekvens av minne som sedan kan indexeras för att hämta eller ändra värden. I exemplet nedan skapas en array som har plats för 40 heltal. int[] v = new int[40]; v[0] = 4; v[3] = v[0]; I Java kan arrayer användas för att lagra både primitiva datatyper men också referenser till objekt. Date[] week = new Date[7]; week[0] = new Date(); Fördelarna med arrayer är att de är snabba att använda då datorn är optimerad för att använda dessa strukturer. Nackdelarna är dock också många. Dels måste man från början veta vilken kapacitet man måste ha. Ett vanlig fel när man använder arrayer är dessutom att man råkar använda index som ligger utanför dem och därmed orsaka fel. 5

6 2.1.2 java.util.vector I Java finns en klass som representerar en sekvens av data, d.v.s. en abstrakt datatyp för att representera en sekvens av data. Denna datatyp bygger på arrayer men dessa är gömda för användaren. Fördelarna med att använda denna klass i stället för arrayer är att man får hjälp med mycket. Ett objekt av Vector-klassen kan t.ex. utöka sig och lagra fler objekt än den först var avsedd för. Hur går då det till? Nyss nämndes ju att den var byggd på arrayer och att dessa kan ju inte utökas. Detta gäller givetvis. Vad som händer är att om man vill använda fler positioner i arrayen än det finns plats för, skapas en ny array med större kapacitet och innehållet i den gamla kopieras över till den nya. Denna datatyp duger gott i många tillämpningar och är smidigare att använda jämfört med vanliga arrayer. 2.2 Länkade strukturer Varför skall man då inte alltid använda arrayer när Vector-klassen löser det mesta av dess nackdelar? Ja, en del av dess egenskaper vi skall studera och se konsekvenserna av för att inse varför vi även skall titta på andra sätt att lagra sekvenser av data. En av dessa egenskaper nämnde vi. Om den inte längre räcker till. Då måste vi skapa en ny vektor och kopiera över det gamla innehållet till den nya. Om detta görs ofta blir det väldigt mycket kopierande. Detta kan i och för sig lösas genom att man tar i ordentligt från början och gör arrayen ordentligt stor. Då har vi istället nackdelen att mycket minne finns reserverat för denna array som kanske aldrig kommer att användas. En annan nackdel är att om vi vill ta bort ett element från arrayen blir det ett hål. Om vi inte vill hålla reda på varhålen finns måste vi täppa till dessa hål. Om ordningen på elementen då är viktig, måste vi flytta alla element som ligger bakom ett hål ett steg för att det åter skall bli tätt. Samma ptroblem får man om man vill lägga till ett element mitt i vektorn. Även då måste samtliga element bakom det nya elementet flyttas ett steg för att det skall rymmas. Detta kan också bliväldigt mycket kopierande om en vektor redigeras ofta. För att undvika problemen med arrayer vill vi därför ha en struktur som kan utökas när så behövs och enkelt minskas om så behövs. Detta görs med s.k. länkade strukturer. En länkad struktur kan man se som en kedja, där varje länk lagrar ett värde och sitter ihop med nästa länk Referenser och pekare Centralt när man arbetar med länkade strukturer är att förstå begreppet referens. För varje ny variabel eller objekt som skapas allokeras (reserveras) så mycket minne som behövs i datorns minne. Varje plats i minnet har också en adress. Adressen till en viss minnesposition används av datorn för att veta var en viss variabel finns. Detta utnyttjas när man skapar referenser till objekt eller variabler. I programspråket C betecknas detta som pekare. När vi skriver Point p; p har vi lärt oss att vi inte skapar ett nytt objekt. Objektet skapas först när vi t.ex. skriver new Point(20,30); x y

7 Om vi alltså skriver Point p = new Point(20,30) p x y skapar vi först en referens, p, i detta fallet en referens till ett objekt av klassen Point. Sedan skapas ett nytt objekt. Först därefter sätts p till att referera det nya objektet. Utan referensen p tappas det nya objektet bort och kan sedan inte användas. Vi kan också ha flera referenser som refererar till samma objekt. Om vi skriver Point p2 = p; kopierar vi inte objektet, utan vi skapar en ny referens som vi tilldelar samma värde som p, d.v.s. vi låter även p2 referera till samma objekt som p. p p2 x y Referenser utnyttjas när vi vill bygga upp länkade strukturer. Varje länk håller alltså reda på ett värde, men också på efterföljande länk med hjälp av en referens. class Link { Object value; Link next; public Link(Object value) { this.value = value; this.next = null; När man bygger upp strukturen skapar man t.ex. först en referens till den första länken. Lämpligen sätter man den initialt till null för att veta om vi har några länkar eller inte. Link first = null; First Därefter kan man börja lägga till nya länkar. Observera vad som händer i konstruktorn i Link. First value next Link n = new Link(new Point(20,30)); first = n; n x y Vill vi nu lägga till en ny länk före det tidigare objektet använder vi referenserna som följer: 1 Link n = new Link(new Point(0,0)); 2 3 n.next = first; 4 first = n; 7

8 First value next First value next n value next x y n value next x y x y x y Figur 2.1: Länkning av ytterligare en länk efter rad 1 respektive rad 4 i kodexemplet Hängde ni med? Observera att vi aldrig kopierade några objekt, utan vi enbart lät referenser byta värde. Först skapade vi en ny länk (rad 1). Därefter lät vi den nya länkens next-attribut refererar till samma objekt som first refererade till (rad 3). Därefter lät vi first referera till den nya länken (rad 4). Resultatet ses i figur 2.1. Enligt denna princip kan långa sekvenser men även mer komplicerade strukturer byggas upp. 2.3 Listor En lista är precis vad det låter som. Precis som en lista vi skriver när man skall handla är elementen ordnade i en sekvens med en inbördes ordning. I en lista kan man även ta bort och lägga till element på en valfri plats. Listans egenskaper gör att den är väldigt vanlig i praktisk programmering där man har en sekvens av data men där man inte från början vet hur stor mängd data som skall lagras. I en lista har man en uppsättning operationer som brukar variera mellan olika implementationer men i princip ser de ut som följer: create() empty list Skapar en tom lista insert(value, position) Lägger till ett nytt värde till listan. remove(position) Tar bort ett värde ur listan. inspect(position) value isempty() boolean length() int Returnerar värdet på en viss position i listan utan att ta bort det. Kollar om listan är tom. Returnerar längden av listan. Här ser man tydligt tanken med abstrakta datatyper. Vi säger enbart vilka operationer vi vill kunna göra, inget om hur dessa skall göras eller hur datat faktiskt lagras Enkellänkade listor Den enklaste typen av länkade listor har vi redan sett ett exempel på ovan. Varje länk håller reda på sigsjälv, samt efterföljande länk. Klassen Link ovan kan fortfarande användas, det enda som behövs är att skapa en klass som implementerar de olika operationerna. Vi skall i detalj och schematiskt, med tillhörande Java-kod, studera de operationer vi kan göra på en enkellänkad lista. Listan vi skall studera är en enkelt implementerad lista som bygger på positioner. Första positionen anges med 0 precis som med arrayer. 8

9 Create Att skapa en ny tom lista blir i ett objektorienterat språk detsamma som att skapa ett nytt objekt av klassen. Eventuella initialvärden sköts av konstruktorn. Listan har två attribut, dels first, som håller reda på först elementet, samt length som håller reda på längden av listan. Den sista är inte nödvändig, men kan vara lämplig av effektivitetsskäl. Försök tänka påvarför den inte är nödvändig samt en vanlig situation när det kan vara bra att hålla reda på längden explicit. public class SingelLinkedList { Link first; int length; public SingelLinkedList() { first = null; length = 0;... SingleLinkedList new SimpleList(); length 0 first inspect En vanlig operation är att man vill kolla vad som finns på viss position i listan utan att för den skull ta bort elementet. Till vår hjälp skall vi här implementera en privat metod som finner en länk på en viss position. private Link findlink(int pos) { if (pos < 0 pos >= length isempty()) throw new IndexOutOfBoundsException(); Link tmp = first; for (int i=0; i < pos; i++) tmp = tmp.next; return tmp; Först kollar metoden om den sökta positionen ligger inom listan. Om inte, kastas ett undantag. Därefter används en temporär referens som börjar med att referera första länken. Därefter räknar sig metoden fram tills den har funnit länken på den sökta positionen. Metoden för att kolla innehållet på en viss position blir nu trivial. Först letar vi upp rätt länk. Därefter returneras objektet som är länkens värde. public Object inspect(int pos) { Link linktoinspect = findlink(pos); return linktoinspect.value; 9

10 insert Att lägga till nya objekt i listan kräver lite fler operationer. Vi använder oss dock av metoden findlink även här för att finna länkar. Denna gång vill vi finna noden som ligger på positionen före den position där vi vill lägga in ett nytt värde. Koden ser du nedan. Observera att vi måste ta hand ett specialfall och det är när listan är tom eller när vi vill lägga till något på första positionen. Studera figur 2.2 för att se hur referenserna ändras. 1 public void insert(object o, int pos) { 2 Link newlink = new Link(o); 3 4 if (isempty() pos == 0) { 5 newlink.next = first; 6 first = newlink; 7 else { 8 Link linkbefore = findlink(pos-1); 9 10 newlink.next = linkbefore.next; 11 linkbefore.next = newlink; length++; 15 value next value next value next value next linkbefore?? linkbefore?? newlink value next newlink value next?? Figur 2.2: En schematisk bild av hur det kan se ut efter rad 8 respektive efter rad 11 i kodexemplet. remove Att ta bort element följer samma mönster som när man lägger till element fast i omvänd ordning. Även när man vill ta bort element letar vi upp länken före den vi vill ta bort och sedan sätter man om dess next-attribut till att i stället referera länken som ligger efter den man vill ta bort. Dessutom bör man sätta eventuella referenser till null för att undvika potentiella fel. Även här finns det specialfall att ta hand om. I figur 2.3 syns hur referenserna ser ut efter rad public void remove(int pos) { 2 Link linktoremove; 3 4 if (pos == 0) { 5 linktoremove = first; 6 first = linktoremove.next; 7 else { 8 Link linkbefore = findlink(pos-1); 10

11 9 10 linktoremove = linkbefore.next; 11 linkbefore.next = linktoremove.next; linktoremove.next = null; 14 linktoremove.value = null; length--; 17 value next value next value next??? linkbefore linktoremove Figur 2.3: En schematisk bild av hur det kan se ut efter rad 11 i kodexemplet Dubbellänkade listor Vad har vi nu vunnit med vår enkellänkad lista jämfört med en vanlig vektor? Ja, det behövs inte kopieras en massa referenser när listan krymper och framförallt kan den växa och krympa helt efter behov. Vad har den för nackdelar då. Ja en uppenbar nackdel när man studerar den är man måste leta upp en viss position när man vill göra något och eftersom vi enbart håller reda på första elementet i listan måste vi alltid starta från början av listan. Detta kan man till viss del undvika genom att skapa en ytterligare referens som håller reda på den senast besökta länken och därmed kan det gå fortare att leta upp en viss länk. Då behöver man nämligen inte börja om från början jämt utan om man vill leta upp samma länk eller någon länk efter den i listan kan man börja därifrån man står. Fortfarande måste man dock börja från början i många fall. Problemet är att vi enbart vet vilken länk som ligger efter en annan. Så fortvivillgåbakåt vet vi inte vad som finns, utan måste starta om från början. Lösningen är att vi lägger till en referens i länken, nämligen en referens till länken före den aktuella i listan. Vi måste alltså modifiera vår länk-klass. class DubbleLink { Object value; Link next; Link prev; public DubbleLink(Object value) { this.value = value; this.next = null; this.prev = null; Listan behöver på detta sätt inte nödvändigtvis hålla reda på första länken i listan utan enbart en referens till den senast besökta noden. Detta eftersom vi nu både kan röra oss fram och tillbaka i listan. I figur 2.4 ser vi en schematisk bild av hur en lista kan se ut och i kodexemplet nedan huvudet på klassen. 11

12 public class DoubleLinkedList { DoubleLink current; int pos; int length;... prev value next prev value next prev value next prev value next???? length pos 4 2 current Figur 2.4: En schematisk bild av hur en dubbellänkad lista kan se ut. 2.4 Stackar Liksom i en lista består en stack av en sekvens av element där element kan läggas till och tas bort. Skillnaden är att i en stack kan enbart element läggas till och tas bort från ena änden. Stackar kallas också för LIFO som är en akronym för Last In First Out, d.v.s. elementet somsistläggs till är det första som tas bort. Tänk på en stapel tallrikar, där man enbart får arbeta med en tallrik åt gången. Vanliga operationer på en stack är create() empty stack push(value) top() value pop() isempty() boolean size() int Skapar en tom stack. Lägger till ett värde överst på stacken. Returnerar det översta värdet i stacken utan att ta bort det. Tar bort översta värdet i stacken Kollar om stacken är tom. Returnerar storleken av stacken. Stackar kan enkelt implementeras med hjälp av en t.ex en enkellänkad lista eller en vektor. Här bör man dock tänka efter hur man bör arbeta i de två fallen. Kom i håg att i en enkellänkad lista är det besvärligt att ta fram det sista elementet i listan och i en vektor måste man kopiera hela vektorn om man tar bort första elementet. Implementerar man stacken med en enkellänkad lista bör man alltså enbartlägga till och ta bort element på första positionen och arbetar man med en vektor bör man lägga till och ta bort element i slutet av vektorn. 12

13 En implementation av en stack med hjälp av en enkellänkad lista kan se ut som kodexemplet nedan. Observera att metodhuvuderna eller på det sätt användaren skulle använda stacken inte påverkas om du använder en enkellänkad lista, en vektor eller om du implementerar stacken helt själv. Detta är styrkan med abstrakta datatyper och objekorienterad programmering. public class Stack { SingleLinkedList stack; public Stack() { stack = new Stack(); public void push(object o) { stack.insert(o, 0); public Object top() { return stack.inspect(0); public void pop() { stack.remove(0); public int size() { return stack.length(); public isempty() { return stack.isempty(); Stackar är flitigt använt inom programmering och även datorers konstruktion. Ofta kan det vara att en fråga om prioritering. Ett exempel kan vara att medan en uppgift bearbetas kommer det en ny uppgift med högre prioritet, då läggs den första till en stack. När den andra uppgiften är färdig fortsätter man med den uppgift som har högst prioritet och den finns då alltid överst på stacken. Andra vanliga exempel är när en uppgift beror på andra deluppgifter. Bearbetas en uppgift som innan den kan slutföras behöver resultatet från en annan uppgift, läggs den på stacken medan den nya uppgiften utförs. Beror den i sin tur på något annat läggs den till stacken osv. När en uppgift är klar kan översta uppgiften på stacken fortsätta o.s.v. Ett vanligt exempel på detta är rekursion Exempel Exemplet jag tänkte visa kommer från skriptspråket PostScript som används vid utskrifter. När man skriver kommandon i PostScript ser det lite annorlunda ut än vi är vana, genom att argumenten kommer först och sedan kommer operationen. Orsaken är enkel och visas genom nedanstående exempel. När man vill att utskriften skall fortsätta från en viss punkt på papperet t.ex. att man vill dra en linje därifrån eller skriva ut en bokstav, används kommandot moveto. Kommandot tar två argument som anger koordinaten (x,y) för punkten. Alltså hurmånga punkter från vänster av papperet och hur många punkter från botten av papperet nästa utskrift skall ske från. Man skriver alltså 13

14 moveto för att flytta till punkten (20,340). Detta verkar ju bökigt. Varför skriver man inte som man är van? Jo ta nu ett lite mer komplicerat uttryck. Antag att vi måste beräkna ett aritmetiskt uttryck för att ta reda på vilken x-koordinat vi vill ha, t.ex. att vi vill flytta till punkten (2*(25+30), 100). Detta skrivs nu som add mult 100 moveto Se vad som händer när vi läser kommandosträngen från vänster till höger och använder en stack. 1. Läser in 2 som läggs till stacken 2 2. Läser in 25 som läggs till stacken Läser in 30 som läggs till stacken Läser in add som kräver två argument som tas från stacken. Resultatet ( = 55) läggs till stacken Läser in mult som kräver två argument som tas från stacken. Resultatet (2 55 = 110) läggs till stacken Läser in 100 som läggs till stacken Läser in moveto som kräver två argument som tas från stack. Resultatet blir att vi flyttar till punken (110,100) 2.5 Köer Köer är en annan vanlig datatyp och har liknande funktion som en stack förutom att nya element läggs till i en ände och element tas bort från den andra änden. Köer kallas också för FIFO som är en akronym för First In First Out, d.v.s. elementet som först läggs till är det första som tas bort. Ibland ser man också LILO,Last In Last Out. Köer är nog kanske den datatyp som känns mest intuitiv då alla nån gång ståttienkö, antingen en telefonkö hos en kundtjänst eller vid kassan på matvarubutiken. Vanliga operationer påköer är: create() empty queue enqueue(value) front() value dequeue() isempty() boolean length() int Skapar en tom kö. Läggger till ett nytt värde i slutet av kön. Returnerar främsta värdetikön utan att ta bort det ur kön. Tar bort främsta värdet i kön. Kollar om kön är tom. Returnerar längden av kön. 14

15 Implementationen behöver inte heller vara svårare än för en stack. Antingen skriver man en egen eller så kan man använda en enkellänkad lista eller vektor. När vi nu måste jobba ibåda ändarna, bör en något modifierad enkellänkad användas än den vi sett exempel på. Enklast är att lägga till en referens till sista länken i listan. På detta vis är det enkelt att lägga till element i slutet av listan och precis som i stacken enkelt att ta bort element i början. Använder man en vektor kan man göra som i kodexemplet nedan för att undvika att data kopieras. Implementationen går ut på att man håller reda på varbörjan och slutet är därmed är inte alltid början på position 0. Därmed kan ocksåkön gå runt, d.v.s. att den börjar i slutet av vektorn och fortsätter i början. Ytterligare kontroller än vad som görs i exempelkoden bör göras för att man inte skall överstiga maximal kapacitet. Observera också användandet av modulosoperatorn (%) som ger resten vid heltalsdivision med den andra operatorn end front public void Queue { Object[] queue; int capacity; int front; int end; public Queue(int capacity) { this.capacity = capacity; queue = new Object[capacity]; front = 0; end = 0; public boolean isfull() { return (end+1)%capacity == front; public void enqueue(object o) { queue[end] = o; end = (end+1)%capacity; public void dequeue() { queue[front] = null; front = (front+1)%capacity; public Object front() { return queue[front]; public boolean isempty() { return front == end; public int length() { return (end+capacity-front)%capacity; 15

16 Köer är troligen ännu mer frekvent använda än stackar. Den vanligaste användningen är att något ställs i kö tills det kan bearbetas senare. Detta gäller allt från program som vill komma åt processorn till musrörelser. 16

17 Kapitel 3 Algoritmer Algoritmer är en noggrann stegvis beskrivning av problemlösningsmetoder. Till en algoritm hör: Indata. De värden algoritmen ges innan den påbörjas. Dessa kan vara noll till antalet. Utdata. De värden som beräknas av algoritmen. Dessa har alltid en speciell relation till indatat. Även dessa kan också vara noll till antalet. Algoritmer har dessutom följande kännetecken: Ändlighet. En algoritm måste garanteras att den blir klar (terminerar) inom ett ändligt antal steg, oavsett vilket indata den ges. Bestämdhet. Varje steg i algoritmen måste vara entydigt och precist definierat. Effektivitet. Varje steg i algoritmen måste vara så elementär att det i princip kan utföras exakt och inom en ändlig tidsrymd. Algoritmer skall skiljas från färdiga program. En algoritm är en mer generell och programspråksoberoende beskrivning, som sedan används som underlag när man implementerar algoritmen i något programspråk. I algoritmer använder man pseudokod för att beskriva de moment som krävs. Ett exempel på algoritm finner du längre ned. 3.1 Komplexitet Även om algoritmer är ändliga, d.v.s att de garanteras att bli färdig, vill man ju gärna veta hur länge man kan förvänta sig att det tar. Kommer det att ta en 1 µs, 1 minut, eller 10 år? Även om en algoritm inte ser så komplicerad ut är det viktigt att se vad det innebär, speciellt när man faktiskt får fler indata. Man ser att den är lätt att utföra när man har 3 värden, men vad händer när vi i stället har hundra, tusen eller en miljon värden? Givetvis tar de flesta algoritmer längre tid när man får fler indata, men frågan är hur mycket längre. Anta att vi har en vektor med 10 siffror och vi vill summera dem. Först skapar vi en algoritm för att lösa detta problem. Input: Vektor, v. Output: Summan, sum av värdena i vektor v. begin sum := 0 for all elements in v do sum := sum + v[i] end end 17

18 Hur många operationer kommer att ske om vi har låt oss säga n element i vektorn? Ja helt klart beror det på hur stort n är. För varje element som n ökar med tillkommer en summation, samt en tilldelning samt att i skall öka. Vad innebär detta då? Ja, fördubblas antalet element i vektorn, kommer också antalet operationer som krävs för att beräkna resultatet att fördubblas. Spelar det nån roll hur många operationer som krävs per element i vektorn då? Nej, egentligen inte. Vi vet att det är ett konstant antal operationer som krävs för varje element. Tar det 1 ms sekund att summera 200 element, kan vi säga att det ungefär kommer att krävas 10 ms att summera 2000 element. Vi kan inte säga exakt vad, för det är så mycket som det beror på, men det som oftast är viktig är att veta att det i alla fall inte kommer att ta 10 s. Låt oss ta ett annat exempel. Ett klassiskt problem är något som kallas handelsresandeproblemet. En handelsresande vill besöka ett antal städer, men frågan är i vilken ordning han skall besöka dem för att få så kort restid som möjligt. Ett sätt är att testa alla kombinationer och välja det som ger kortast tid. Enkelt! Eller? Har vi två städer, A och B blir antalet kombinationer två, antingen A B eller B A. Om vi har tre städer får vi 6 kombinationer, A B C, A C B, B A C, B C A, C A B och C B A. För varje ny stad vi lägger till de befintliga städerna ökar antal kombinationer lika många gånger som det totala antalet. Har vi 6 städer, finns det = 720 kombinationer. Om det tar 10 ms att kolla dessa 720 kombinationer, hur lång tar det då att kolla antalet kombinationer om vi har 50 städer. 100 ms? eller 1 timme? Svaret är över årtusenden. Det är alltså högst väsentligt vilken algoritm vi använder och vilken typ av problem vi bestämmer oss för att lösa. Begreppet kallas komplexitet, d.v.s. hur komplex en algoritm är och därmed hur fort det totala antalet operationer ökar när antal inputvärden ökar. Till vår hjälp skall vi använda ett begrepp som ger oss en matematiskt värde av hur komplex en algoritm är. Ta en matematisk funktion f(n) som t.ex. beskriver antalet operationer som krävs vid n input värden. Operationer (tid) f(n) Problemstorlek (n) Vi ser hur den efter att haft en puckel vid få indata, sedan stadigt växer när indatat växer för att på slutet mattas något. Vi skall nu ta en annan funktion, g(n). Vårt mål är att g(n) skall beskriva en övre gräns för hur stor f(n) kan bli. Som vi såg tidigare är inte det konstanta antalet funktioner som sker per n intressant, varför vi kan skala vår funktion med en konstant c om det visar sig att g(n) är lite för liten. 18

19 Operationer (tid) c g(n) f(n) n 0 Problemstorlek (n) Vi ser här att vi har funnit en funktion g(n) somföljer f(n) ganska väl och som till största delen befinner sig en bit ovanför och begränsar f(n). Däremot är faktiskt f(n) större än g(n) vid små n, men detta gör inte så mycketdåviär intresserad av att hitta en begränsning när n växer mot riktigt stora tal och vi kan se att när n växer ser inte f(n) ut att närma sig g(n). Man säger här att f(n) är O(g(n)) om och endast om f(n) <c g(n) för alla n>n 0. Detta brukar uttalas som att f(n) är ordo g(n). I praktiken vill man välja g(n) så att den beskriver med vilken magnitud f(n) växer. Man vill inte välja g(n) för stor, men samtidigt inte för detaljerad. Vilken komplexitet har då våra algoritmer beskrivna ovan. Den första som beräknade summan krävde dubbelt så mycket beräkningar när n fördubblades. Antalet operationer växer med n och sägs ha komplexiteten O(n). Vi kan hitta en funktion g(n) =c n som begränsar antalet operationer den utför där c är en konstant. Vi vet inte exakt vad den är. Den kan vara 10 eller 30 men det spelar ingen roll när n växer. Vi vill som sagt veta om det tar 1 sekund eller 1 timme att beräkna en summa när n växer inte om det tar 5 eller 15 sekunder. Observera att denna algoritm också är O(n 2 )ocho(n 3 ), men vi att algoritmen skall beskrivas så väl som möjligt. Den andra algoritmen som handlade om handelsresanden som visade sig vara särdeles otrevlig har komplexiteten O(n!), d.v.s. n-fakultet som är n(n 1)(n 2) Observera också följande: 1. Om f(n) är O(a g(n)), är f(n) också O(g(n)). Exempel: 1000 n är O(n). 2. Om f(n) är O(g(n) + h(n)) är f(n) O(max{g(n),h(n)). Exempel: O(n 2 + n)=o(n 2 ). 3. f(n)+h(n) är O(max{f(n),h(n)). Exempel: 100 n 2 + log(n) =O(n 2 ). 4. Om f(n) är ett polynom av graden d, alltså att f(n) =a 0 + a 1 n a d n d,såär f(n) O(n d ). Exempel: n 2 +40n 3 =O(n 3 ). 19

20 Kapitel 4 Sortering Att ha data av något slag i listor och vektorer ärsomviförstått rätt vanligt inom programmering. Nästa uppgift blir att använda datat och en vanlig operation är att sortera datat pånågot vis, t.ex. strängar efter bokstavsordning eller tidsangivelser i kronologisk ordning. Att sortera några siffror i stigande ordning känns ju instinktivt inte så svårt, det är ju bara att först ta den minsta o.s.v. I stort sett är det också bara att göra så, men problemet är just att finna i detta fall den minsta. I slutänden måste vi för att kunna sortera en mängd data i efter någon ordning jämföra varje element i datat med alla andra element. Hur görs detta bäst? Det finns många sorteringsalgoritmer och vi kommer här att kolla närmare på några och jämföra dem inbördes. 4.1 Bubble sort En enkel och lättimplementerad algoritm kallas bubbel sort eftersom elementen liksom bubblar upp genom datat. Principen är att gå från en ände till den andra och jämföra elementen parvis och byta plats på dem om det är nödvändigt. Givetvis räcker det oftast inte med att gå igenom vektorn eller listan en gång utan detta måste upprepas fler gånger. Ivärsta fallet måste det upprepas n 1gånger om det finns n element i listan eller vektorn. Algoritmen kan du se nedan och i figur 4.1 finns ett exempel. Input: Vektor eller lista, list, med n element. Output: Input-vektorn är sorterad i stigande ordning. while not done do done := true for i = 0 to n-2 do if list[i] > list[i+1] then swap(list[i], list[i+1]) done := false; end end end Vad har vi för komplexitet på bubble sort? Antag att vi har n element som skall sorteras. I for-loopen utförs några operationer för varje varv den loopar och den loopar n 1gånger. Det antalet operationer som görs för varje loop-varv skiljer något. I bland måste element byta plats och ibland inte. Dock kan vi ta reda på ett max antal operationer som utförs och de beror inte på antalet element i vektorn, d.v.s. det görs som flest a(n 1) operationer där a är en konstant. Den inre loopen upprepas dock så länge inte vektorn är färdigsorterad. Hur många gånger den upprepas vet vi inte, men vi vet att det är i värsta fallet n 1 gånger. Detta innebär att vi i värsta fallet sammanlagt kommer att utföra (n )(n 1)a 20

21 Ursprunglig vektor Varv 1: Byte 7 5, 7 4, Varv 2: Byte 5 4, Varv 3: Byte Varv 4: Byte Varv 5: Inga byten Figur 4.1: Exempel på hur bubble sort arbetrar på en vektor med 5 element. operationer. Då det ur komplexitetssynpunkt inte är viktigt med enskilda konstanter blir alltså komplexiteten för Bubbelsort O(n 2 ). Detta innebär att får vi dubbelt så många element kommer det att ta fyra gånger så lång tid att sortera dem. Finns det då något effektivare sätt att lösa detta på? Trots allt måste ju varje elementen jämföras med alla andra och har vi n element måste det då intetan n operationer? 4.2 Merge sort I en sorteringsalgoritm som kallas merge sort kommer vi att utföra lite magi. Vi kommer att jämföra varje element med alla andra utan att faktiskt göra det och därmed spara tid. Det första som görs är att splittra vektorn i lika många små vektorer som det finns element, d.v.s. så att varje element kommer i en egen liten vektor. Givetvis behöver man inte fysiskt splittra på vektorn i minnet, men man ser den nu som ett antal små vektorer Orginalvektor Därefter paras vektorerna ihop två och två. Därefter jämförs första elementet i den ena av vektorerna med det första i den andra. Det minsta av dem blir första elementet i en ny vektor. Man fortsätter sedan att jämföra de första av de kvarvarande elementen så länge det finns element kvar i någon av de två vektorerna samt för alla vektorpar. Det minsta av dem blir nästa element i den nya vektorn o.s.v. I första varvet har de enskilda vektorerna dock bara ett element. I vårt exempel har vi 7 element. Efter att ha parat ihop elementen två ochtvåochjämfört dem och lagt dem i nya vektorer har vi nu 4 vektorer. Observera att de 4 vektorerna är internt sorterade Splittning Resultat 1:a sorteringen Det senaste steget upprepas nu för de fyra kvarvarande vektorerna. Vi parar i hop två nya vektorer och jämför det första elementen i dem. Det minsta blir det första elementet i en ny vektor, det andra elementet blir det minsta av de två nya första elementen o.s.v. Resultatet av de fyra vektorerna har blivit två nya. 21

22 Resultat 1:a sorteringen Resultat 2:a sorteringen Samma procedur upprepas tills vi fått endast en sammanhängande vektor Resultat 2:a sorteringen Resultat 3:e sorteringen Observera att vi endast jämför de två första elementen i vektorerna. Eftersom vi vet att vektorerna är sorterade internt behöver vi alltså enbartjämföra 2:an i [ ] med 3:an i[348]för att veta att 2:an är det minsta av dem alla. Därefter kan man jämföra 5:an i [5 7 9] med 3:an [3 4 8] för att veta att 3:an är den näst minsta av de kvarvarande. Det är just detta som är det fina med merge sort, men hur mycket i tid tjänar vi? Det första vi skall kolla är hur många operationer som krävs varje varv i algoritmen när vi bygger upp de nya vektorerna. För varje nytt element vi lägger till en av de nya vektorerna behövs enbart en jämförelse. Och eftersom det är sammanlagt n element är det i storleksordningen n operationer som krävs. Hur många gånger måste detta upprepas då? I varje varv slog vi ihop två vektorer till en. I exemplet ovan var det 7 element och vi behövde 3 i hopslagningar. Hade vi haft mellan 9-16 element hade det krävts 4 i hopslagningar. Antal i hopslagningar som krävs är helt enkelt samma som det antal gånger man kan dela n med 2, d.v.s. 2-logaritmen av n avrundat uppåt eller log 2 (n). Totalt krävs alltså O(n log 2 (n)) operationer. Hur stor skillnad gör då det? Ja, låt oss jämföra dem när n ökar. I tabellen nedan är n, n 2 och n log 2 (n) uppställda för några n samt vad detta skulle motsvara i tid om vi antar att 64 operationer skulle motsvara 1 ms. Givetvis är detta inte alls nån precis angivelse på vaden verkligt program skulle ta i verkligheten, men det ger en uppfattning om storleksordningen på talen. n n 2 n log 2 (n) ms 64 1 ms ms ms s ms s ms m 22 s ms h 10 m ,5 s h 38 m s Det är helt uppenbart att när n växer kan vi känna mycket med en algoritm av lägre komplexitet. Måst vi betala något för detta? Ja, dels är merge sort betydligt mer komplicerad att implementera jämfört med t.ex bubble sort dessutom blir det mer att hålla reda på vilket gör att om datamängderna förhållandevis små, blir inte tidsskillnaden såstor. Dessutom har merge sort en annan stor nackdel och det är att den kräver betydligt mer minne. Vi måste hela tiden jobba med två vektorer, d.v.s. 2 n i minne när bubble sort enbart kräver n + 1 i minne. Detta kanske inte alltid är avgörande, men kan vara värt att tänka på om datamängderna är skrymmande. Principen som merge sort bygger på något som brukar kallas devide and conquer, söndra och härska. Genom att dela upp problemet i mindre delproblem som löses var för sig kan man lösa hela problemet effektivare. 22

23 4.3 Quick sort Quick sort är en annan algoritm som också bygger på devide and conquer principen. I quick sort väljes ett pivot-element, Alla element som är mindre än elementet läggs på en sida och alla som är större läggs på den andra sidan. På varje delmängd väljes nu ett nytt pivot-element. Proceduren upprepas tills dess att varje delmängd endast har ett element vilket innebär att vektorn är sorterad. Väljes pivot-elementet hela tiden som det mellersta av respektive delmängd krävs lika många operationer som i merge sort och den har alltså komplexiteten O(n log 2 (n)). Fördelen gentemot merge sort är dessutom att den kan göras så ett den inte kräver mer minne. Problemet är dock att välja lämpliga pivot-element. Väljes t.ex. hela tiden det minsta elementet i varje delmängd kommer algoritmen att gå lika långsamt som bubble sort när den presterar som sämst. Algoritmen är dock populär då den ofta presterar bra och inte kräver mycket minne. 4.4 Vad skall man välja? Vad skall man då göra? Givetvis bör man alltid försöka få sina program att gå fortannars upplever användarna att det går segt och trögt. Är datamängderna små och det kanske är 10 element som behöver sorteras, använd en liten bubbel sort som lätt implementeras, annars sök bättre och färdiga sorteringsalgoritmer som du kan användas i programmet. 23

24 Kapitel 5 Grenade strukturer Vektorer och listor i all ära, men alla typer av data passar inte in i dessa strukturer. Vill man t.ex. beskriva en företagsorganisation med avdelningar och underavdelningar som rapporterar till varandra eller ett vägnät mellan olika orter passar inte en vektor eller lista så bra. Det finns alltså imånga sammanhang anledning att kolla på andra typer av datastrukturer och abstrakta datatyper. Principen bygger oftast på den länkade modell vi sett tidigare. Vi har länkar eller noder som lagrar vårt data och referenser till andra länkar eller noder beskriver deras relation. I listan hade vi en relation mellan länkarna som före och efter, men de kan givetvis vara helt annorlunda. 5.1 Träd Ett träd är ett mycket vanligt sätt att beskriva en viss typ av data. Olika typer av hierarkier haroftaenträdstruktur, t.ex. gamla tiders ledarstrukturer, men en kung i toppen med hans underlydande längre ned i hierarkien men det kan även vara internetdomäner eller designen hos olika webb-sidor hos ett företag där man utgår från en framsida som sedan länkar till andra sidor som i sin tur länkar till andra o.s.v. Ett träd har ett antal egenskaper som vi först skall definiera. Motsvarigheten till en länk i listor kallas för noder, d.v.s. noderna lagrar datat. Noderna i sin tur förbinds med kanter. Varjenodkanhaflerabarn, d.v.s. andra noder som den är förbunden till med kanter. Varje nod har en och endast en förälder, utom den så kallade roten som saknar förälder, men som dock kan ha barn. Noder utan barn kallas för löv. Enkelt uttryckte kan man säga som vår Lennart Edblom 1 en gång har uttryckt det. Ett träd ser ut som en upp och ned vänd buske. Vi har roten överst och trädet grenar sedan ut sig nedåt med löven längst nere. Egenskapen att varje nod enbart kan ha en förälder leder till att det aldrig kan finnas loopar i ett träd, d.v.s. noder som både är barn och föräldrar. Varje nod är dessutom själv roten till ett delträd. Det maximala antalet nivåer av barn hos ett träd kallas dess djup. 1 Lärare och prefekt på datavetenskapliga institutionen 24

25 Nod Kant Rot Delträd löv Precis som vid länkade listor använder vi referenser för att hålla koll på grannarna. I ett träd måste vi t.ex. ha referenser till nodens barn och eventuellt även föräldern till en nod. Dåviiettträd kan ha flera barn måste referenserna till barnen hållas i en lista eller vektor som utökas om noden får fler barn. public class TreeNode { TreeNode parent; TreeNode[] children; Object value;... Träd är också vanliga inom artificiell intelligens där man pratar om beslutsträd, d.v.s ett beslut följs av ett antal nya beslut. Efter att ha fattat ett beslut kan man inte gå tillbaka utan måste välja bland de nya som nu står till ens förfogande. På så vis vandrar man djupare och djupare ned i träd som troligen ser olika ut beroende på vilka beslut man tar. I ett sådant fall kanske inte trädet har något slut, utan förgrenar sig i det oändliga. 5.2 Binära träd En speciell och mycket viktig typ av träd kallas för binära träd. Namnet binär kommer av ett binärt träd max har två barn, ett vänsterbarn och ett högerbarn. Dessa träd ha egenskaper som gör dem väldigt lämpliga för många uppgifter. Exemplet jag tänkte visa är sökning och så kallade binära sökträd. För att vi skall ha något att jämföra med, kollar vi först på hursökning går till listor eller vektorer. I en osorterad vektor har vi inget att gå påochmåste helt enkelt gå igenom elementen ett och ett tills vi hittar det. Finns där n element tar det som mest n operationer och kanske n/2 i genomsnitt, men fortfarande O(n). I en sorterad vektor kan det gå fortare. Vi kan börja och undersöka elementet i mitten, är det sökta mindre än det jämför vi med det mellersta av de mindre elementen osv På detta vis kan vi få ned söktiden till O(log 2 (n)). Problemet är att det tar O( log 2 (n)) operationer att först sortera vektorn. Att lägga till nya element i en sorterad lista tar ofta också O(n) i tid. I en länkad lista måste vi traversera listan tills vi hittar rätt position och 25

26 i en vektor kan det gå fort att hitta platsen men sedan måste vi kanske flytta på samtliga element för att få plats med ett nytt element. Hur fungerar då ett binärt sökträd? Definitionen är att vänsterbarnet är mindre än noden själv och högerbarnet är större än noden själv. Detta leder till att alla noder i det delträd där ett vänsterbarn är rot alla är mindre än vänsterbarnets förälder och alla noder i det delträd som där ett högerbarn är rot är alla större än högerbarnets förälder Figur 5.1: Binärt sökträd med 16 noder och djup 3 Om vi nu vill hitta 27 i trädet som illustreras i figur 5.1 kan vi gör det på 4jämförelseoperationer. 1. Jämför med roten. 27 < 43 alltså bör 27 finnas i rotens vänstra delträdet. 2. Jämför med rotens vänsterbarn. 27 > 23 alltså bör 27 finnas i 23:ans högra delträd. 3. Jämför med 23:ans högerbarn. 27 < 31 alltså bör 27 finnas i 31:ans vänstra delträd. 4. Jämför med 31:ans vänsterbarn. 27 = 27 och noden är funnen. Hur lång tid tar det alltså att finna en nod i ett binärt sökträd? Vi kommer aldrig att behöva backa upp i trädet, utan för varje jämförelse går vi ett steg längre ned i trädet. Det maximala antalet jämförelser vi behöver göra är alltså bestämtavdjupetpåträdet. Hur djupt är då trädet? Trädets djup beror på om det är balanserat eller inte. Ett träd är balanserat när det skiljer som mest 1 mellan det grundaste och djupaste stället i trädet. I ett balansert träd är djupet log 2 (n), och i ett obalanserat träd kan djupet vara så mycketsomn 1. Exempel på ett obalansert träd finns i figur 5.2. Det beror alltså påomträdet är balanserat eller inte om det är effektivt att söka i ett binärt sökträd eller inte, jämfört med en (sorterad) lista eller vektor. Att balansera ett träd är dock inte så besvärligt, men kan kräva n operationer. Figur 5.2: Exempel på ett obalanserat träd. Att sätta in noder i ett binärt sökträd är också tämligen enkelt och följer samma princip som när man söker, fast när man inte hittar något barn att jämföra med är det också platsen som noden skall sättas in på. 26

27 En nod i ett binärt sökträd skrivet i Java skulle ha ett liknande huvud: public class BinaryNode { Object value; TreeNode parent; TreeNode leftchild; TreeNode rightchild;... public int compareto(binarynode n) { return value.compareto(n.value); Traversering Man brukar prata om tre sätt att systematiskt traversera ett träd om man vill besöka alla noder. Observera att varje nod är rot till ett delträd. Vänster delträd Höger delträd Preorder Besök först roten, därefter vänster delträd och sist höger delträd. Inorder Besök först vänster delträd, därefter roten och sist höger delträd. Postorder Besök först vänster delträd, därefter höger delträd och sist roten. Besöker man noderna i ett binärt sökträd i t.ex. inorder får vi noderna i en sorterad ordning. Exempel Följande träd beskriver ett aritmetiskt uttryck. Trädets noder utgörs av uttryckets operatorer samt dess operander. I uttrycket är +:et ett exempel på en operator och 2:an och 3:an är dess operander. Vårt mål är dels att skriva ut uttrycket samt beräkna det

28 För att skriva ut uttrycket använder vi oss av inorder, d.v.s. först skriver vi ut vänster delträd, sedan roten och sist höger delträd. För att öka tydligheten sätter vi parenteser innan vi besöker en nods vänstra delträd samt efter att höger delträd är besöktomnoden har barn. Då roten har ett vänsterbarn tar vi vänster delträd först, men både +:et och * har också vänsterbarn, så första noden att besöka blir 1:an. Sedan det delträdets rot, nämligen noden med ett *, därefter högerbarnet, 3. Vi har nu: (((4 * 3) Därefter fortsätter vi i inorder tills vi har besökt hela trädet (((4 * 3) + (((4 * 3) + ((6 (((4 * 3) + ((6 - (((4 * 3) + ((6-5) (((4 * 3) + ((6-5) + ( (((4 * 3) + ((6-5) + (2 (((4 * 3) + ((6-5) + (2 * (((4 * 3) + ((6-5) + (2 * 3))) (((4 * 3) + ((6-5) + (2 * 3))) - (((4 * 3) + ((6-5) + (2 * 3))) - 9) För att beräkna uttrycket används istället postorder. För att kunna beräkna summan med plus måste vi nämligen ha ett värde på båda dess operander. I exemplet ovan måste vi t.ex ha ett värde på 6 5samt2 3för att kunna beräkna (6 5) + (2 3). Först efter att ha besökt både vänster och högerdelträd kan vi göra en beräkning med operatorn. 5.3 Grafer En graf består av ett antal noder som är sammanlänkade av kanter. Träd är exempel på en speciell typ av graf, men grafer kan innehålla loopar och det behöver inte finnas en speciell inbördes relation mellan noderna. Grafer kan dessutom vara båda sammanhängande men även osammanhängande, d.v.s. det behöver inte alltid finnas en väg från en nod till en annan. Ett typiskt sätt att se en graf är t.ex ett vägnät eller flygrutter, där varje vägkorsning respektive flygplats är en nod. I båda fallen finns ingen speciell relation mellan noderna och dessa grafer är oftast sammanhängande men kan även vara osammanhängande, t.ex. är vägnätet på en ö inte nödvändigtvis sammankopplat med vägnätet på fastlandet. Figur 5.3: Exempel på en osammanhängande graf med ett antal noder och kanter. I en graf har dessutom ofta kanterna en speciell betydelse och inte bara noderna. Dels kan en kant vara enkel respektive dubbelriktad. I en enkelriktad kant kan du bara gå från den ena noden till den andra men inte andra hållet. Jämför detta med en referens. Ett objekt som har en referens till en annat objekt känner till det objektet, men det refererade objektet känner inte till det objekt som refererar. I en dubbelriktad kant kan man gå från båda noderna till varandra. Dra också parallellen till en enkel respektive dubbelriktad gata. I grafer kan kanter också varaviktade. Det är alltså inte bara noder som kan ha värde utan även kanten. Det kan t.ex. vara en graf som beskriver ett vägnät, där vikten på kanten motsvarar avståndet eller restiden mellan noderna. 28

29 Figur 5.4: Exempel på en sammanhängande graf med riktade och viktade kanter. 5.4 Sökordning När det gäller grenade strukturer som grafer och träd är det ofta sökning som är en viktig uppgift. Är det t.ex en graf som beskriver ett vägnät, är vi kanske intresserad av att hitta inte bara en väg mellan två noder utan dessutom den kortaste vägen. Andra exempel är inom spel m.m., t.ex ett program som spelar schack. Den bygger upp ett träd beroende på vilka möjliga pjäser den kan flytta och vilka motdrag motståndaren kan göra beroende på vilken pjäs som flyttas. Sådana träd kan bli väldigt stora. Sedan försöker programmet finna en vägiträdet som ger honom de flesta fördelarna. Här finns det dock flera olika strategier. Det är inte alltid så lätt som det verkar. Vad händer t.ex om trädet är oändligt djupt och hur förhindrar vi att vi går runt runt i en graf som innehåller en loop Djupet först Djupet först går ut på att efter vi har besökt en nod, så går vi till någon ny nod den är kopplad till o.s.v. Detta upprepas tills dess man kommer till en nod som inte har någon ny nod kopplad till sig. Vid det läget backar man ett steg och ser om den noden hade någon annan ny nod man kan besöka och fortsätta därifrån. Hela tiden måste man hålla reda på vilka noder som är besökta Om man söker i oändligt eller väldigt djupa träd är ju detta ingen bra sökalgoritm. Missar man målet när man passerar kommer man aldrig att kunna hitta det. Därför kombineras oftast denna algoritm vid den typen av problem med en begränsning av hur djupt algoritmen får gå innan den skall söka nya vägar Bredden först Bredden först undersöker som namnet antyder samtliga grannar till en nod innan den fortsätter till en ny nod. Efter att noderna till en nod undersöks går man tillbaka till den nod som först undersöktes i förra iterationen