Graftraversering

Inom datavetenskap avser graftraversering (även kallat grafsökning) processen att besöka, kontrollera och/eller uppdatera varje nod i en graf. Sådana traverseringar klassificeras efter i vilken ordning noderna besöks. Trädtraversering är ett specialfall av graftraversering.

Redundans

Till skillnad från trädtraversering kan graftraversering kräva att vissa noder besöks mer än en gång, eftersom det inte nödvändigtvis är känt innan man går vidare till en nod att den redan har undersökts. När grafer blir mer täta blir denna redundans vanligare, vilket ökar beräkningstiden. När grafer blir glesare gäller det motsatta.

Därför är det oftast nödvändigt att komma ihåg vilka noder som redan har undersökts av algoritmen, så att noder återbesöks så sällan som möjligt eller, i värsta fall, för att förhindra att traverseringen fortsätter oändligt. Detta kan göras genom att varje nod i grafen kopplas till ett "färg"- eller "besökstillstånd" under traverseringen, som sedan kontrolleras och uppdateras när algoritmen besöker noden. Om noden redan har besökts ignoreras den och den vägen följs inte vidare. Annars kontrollerar eller uppdaterar algoritmen noden och fortsätter längs den aktuella vägen.

Flera specialfall av grafer innebär att besök av andra noder redan framgår av deras struktur, och då behöver besök inte registreras uttryckligen under traverseringen. Ett viktigt exempel är ett träd: under en traversering kan man anta att alla "förfäder" till den aktuella noden, och ibland även andra noder beroende på algoritm, redan har besökts. Både djup-först-sökning och bredd-först-sökning är anpassningar av trädbaserade algoritmer, som främst skiljer sig genom avsaknaden av en strukturellt bestämd rot samt tillägget av en datastruktur för att registrera traversalens besökstillstånd.

Algoritmer för graftraversering

Om varje nod i en graf ska traverseras med en trädbaserad algoritm, såsom DFS eller BFS, måste algoritmen anropas minst en gång för varje sammanhängande komponent i grafen. Detta kan enkelt göras genom att iterera över alla grafens noder och utföra algoritmen på varje nod som fortfarande är obesökt när den granskas.

Djupet först-sökning

Djupet först-sökning (DFS, av engelskans depth-first search) är en algoritm för traversering av en ändlig graf. DFS besöker barnnoder före syskonnoder; den följer alltså djupet i en viss väg innan den undersöker dess bredd. En stack, ofta programmets anropsstack via rekursion, används vanligen vid implementationen.

Algoritmen börjar med en vald startnod. Därefter går den stegvis från den aktuella noden till en angränsande, obesökt nod, tills det inte längre finns någon oupptäckt nod att gå vidare till från den aktuella positionen. Algoritmen går då tillbaka längs tidigare besökta noder tills den hittar en nod som är förbunden med ännu oupptäckt område. Därefter fortsätter den längs den nya vägen på samma sätt som tidigare, backar när den når återvändsgränder och avslutas först när algoritmen har backat förbi den ursprungliga startnoden.

DFS ligger till grund för många grafalgoritmer, bland annat topologisk sortering och testning av planaritet.

Pseudokod

• Indata: En graf G och en nod v i G.
• Utdata: En märkning av kanterna i den sammanhängande komponenten till v som upptäcktskanter och bakåtkantar.

procedur DFS(G, v)
    märk v som utforskad
    för alla kanter e i G.incidentEdges(v) gör
        om kanten e är outforskat då
            w ← G.adjacentVertex(v, e)
            om noden w är outforskat då
                märk e som en upptäcktskant
                anropa rekursivt DFS(G, w)
            annars
                märk e som en bakåtkant

Bredden först-sökning

Bredden först-sökning (BFS, av engelskans breadth-first search) är en annan teknik för traversering av en ändlig graf. BFS besöker syskonnoder före barnnoder och använder en kö under sökprocessen. Algoritmen används ofta för att hitta den kortaste vägen från en nod till en annan i en oviktad graf.

Pseudokod

• Indata: En graf G och en nod v i G.
• Utdata: Den närmaste noden till v som uppfyller vissa villkor, eller null om ingen sådan nod finns.

procedur BFS(G, v)
    skapa en kö Q
    lägg v sist i Q
    markera v
    så länge Q inte är tom gör
        w ← Q.dequeue()
        om w är det vi söker då
            returnera w
        för alla kanter e i G.adjacentEdges(w) gör
            x ← G.adjacentVertex(w, e)
            om x inte är markerad då
                markera x
                lägg x sist i Q
    returnera null

Tillämpningar

Bredden först-sökning kan användas för att lösa många problem inom grafteori, till exempel:

• att hitta alla noder inom en sammanhängande komponent;
• Cheneys algoritm;
• att hitta den kortaste vägen mellan två noder;
• att testa om en graf är bipartit;
• Cuthill–McKee-algoritmen för numrering av nät;
• Ford–Fulkersons algoritm för att beräkna maximalt flöde i ett flödesnätverk;
• serialisering och deserialisering av ett binärt träd jämfört med serialisering i sorterad ordning;
• algoritmer för labyrintgenerering;
• flood fill-algoritmen för att markera sammanhängande områden i en tvådimensionell bild eller en n-dimensionell array;
• analys av nätverk och relationer.

Grafutforskning

Problemet med grafutforskning kan ses som en variant av graftraversering. Det är ett onlineproblem, vilket innebär att information om grafen endast avslöjas under algoritmens körning. En vanlig modell är följande: givet en sammanhängande graf G = (V, E) med icke-negativa kantvikter startar algoritmen vid en viss nod och känner då till alla utgående kanter från noden och de noder som ligger i slutet av dessa kanter, men inget mer. När en ny nod besöks blir åter alla utgående kanter och ändnoder kända. Målet är att besöka alla n noder och återvända till startnoden, samtidigt som summan av turens vikter ska vara så liten som möjligt. Problemet kan också förstås som en särskild version av handelsresandeproblemet, där den handelsresande måste upptäcka grafen under färdens gång.

För allmänna grafer är de bäst kända algoritmerna för både oriktade och riktade grafer en enkel girig algoritm:

• I det oriktade fallet är den giriga turen högst O(ln n) gånger längre än en optimal tur. Den bästa kända undre gränsen för varje deterministisk onlinealgoritm är 10/3.
  • Oriktade grafer med enhetsvikter kan utforskas med ett konkurrensförhållande på 2 − ε, vilket redan är en skarp gräns för tadpole-grafer.
• I det riktade fallet är den giriga turen högst (n − 1) gånger längre än en optimal tur. Detta motsvarar den undre gränsen (n − 1). En analog konkurrensmässig undre gräns på Ω(n) gäller också för randomiserade algoritmer som känner till koordinaterna för varje nod i en geometrisk inbäddning. Om målet i stället för att besöka alla noder endast är att hitta en enda "skatt"-nod, är de konkurrensmässiga gränserna Θ(n²) på riktade grafer med enhetsvikter, både för deterministiska och randomiserade algoritmer.

Universella traverseringssekvenser

En universell traverseringssekvens är en sekvens av instruktioner som beskriver en graftraversering för varje reguljär graf med ett givet antal noder och för varje startnod. Aleliunas med flera använde ett probabilistiskt bevis för att visa att det existerar en universell traverseringssekvens med ett antal instruktioner proportionellt mot O(n⁵) för varje reguljär graf med n noder. Stegen som anges i sekvensen är relativa till den aktuella noden, inte absoluta. Om den aktuella noden till exempel är v_j och v_j har d grannar, kommer traverseringssekvensen att ange nästa nod att besöka, v_j+1, som den i:te grannen till v_j, där 1 ≤ i ≤ d.

Se även

• External memory graph traversal