Wie erkenne ich eine Schleife in einer verknüpften Liste?

Angenommen, Sie haben eine verknüpfte Listenstruktur in Java. Es besteht aus Knoten:

class Node {
    Node next;
    // some user data
}

und jeder Knoten zeigt auf den nächsten Knoten, mit Ausnahme des letzten Knotens, der für den nächsten Null hat. Angenommen, es besteht die Möglichkeit, dass die Liste eine Schleife enthält - dh der letzte Knoten hat anstelle einer Null einen Verweis auf einen der Knoten in der Liste, die davor standen.

Was ist die beste Art zu schreiben?

boolean hasLoop(Node first)

Was würde zurückkehren, truewenn der angegebene Knoten der erste einer Liste mit einer Schleife ist, und falseansonsten? Wie können Sie so schreiben, dass es konstant viel Platz und eine angemessene Zeit benötigt?

Hier ist ein Bild davon, wie eine Liste mit einer Schleife aussieht:

Sie können den Zyklusfindungsalgorithmus von Floyd verwenden , der auch als Schildkröten- und Hasenalgorithmus bezeichnet wird .

Die Idee ist, zwei Verweise auf die Liste zu haben und sie mit unterschiedlicher Geschwindigkeit zu verschieben . Bewegen Sie einen nach 1Knoten vorwärts und den anderen nach 2Knoten.

• Wenn die verknüpfte Liste eine Schleife hat, werden sie sich definitiv treffen.
• Andernfalls wird eine der beiden Referenzen (oder deren next) null.

Java-Funktion zur Implementierung des Algorithmus:

boolean hasLoop(Node first) {

    if(first == null) // list does not exist..so no loop either
        return false;

    Node slow, fast; // create two references.

    slow = fast = first; // make both refer to the start of the list

    while(true) {

        slow = slow.next;          // 1 hop

        if(fast.next != null)
            fast = fast.next.next; // 2 hops
        else
            return false;          // next node null => no loop

        if(slow == null || fast == null) // if either hits null..no loop
            return false;

        if(slow == fast) // if the two ever meet...we must have a loop
            return true;
    }
}

Hier ist eine Verfeinerung der Fast / Slow-Lösung, die Listen mit ungeraden Längen korrekt verarbeitet und die Klarheit verbessert.

boolean hasLoop(Node first) {
    Node slow = first;
    Node fast = first;

    while(fast != null && fast.next != null) {
        slow = slow.next;          // 1 hop
        fast = fast.next.next;     // 2 hops 

        if(slow == fast)  // fast caught up to slow, so there is a loop
            return true;
    }
    return false;  // fast reached null, so the list terminates
}

Besser als Floyds Algorithmus

Richard Brent beschrieb einen alternativen Zykluserkennungsalgorithmus , der dem Hasen und der Schildkröte [Floyds Zyklus] ziemlich ähnlich ist, außer dass sich der langsame Knoten hier nicht bewegt, sondern später an die Position des schnellen Knotens bei fest "teleportiert" wird Intervalle.

Die Beschreibung finden Sie hier: http://www.siafoo.net/algorithm/11 Brent behauptet, sein Algorithmus sei 24 bis 36% schneller als der Floyd-Zyklusalgorithmus. O (n) Zeitkomplexität, O (1) Raumkomplexität.

public static boolean hasLoop(Node root){
    if(root == null) return false;

    Node slow = root, fast = root;
    int taken = 0, limit = 2;

    while (fast.next != null) {
        fast = fast.next;
        taken++;
        if(slow == fast) return true;

        if(taken == limit){
            taken = 0;
            limit <<= 1;    // equivalent to limit *= 2;
            slow = fast;    // teleporting the turtle (to the hare's position) 
        }
    }
    return false;
}

Eine alternative Lösung zu Turtle and Rabbit, nicht ganz so schön, da ich die Liste vorübergehend ändere:

Die Idee ist, die Liste zu durchlaufen und sie im Laufe der Zeit umzukehren. Wenn Sie dann zum ersten Mal einen Knoten erreichen, der bereits besucht wurde, zeigt sein nächster Zeiger "rückwärts", wodurch die Iteration wieder in Richtung firstfortgesetzt wird, wo sie endet.

Node prev = null;
Node cur = first;
while (cur != null) {
    Node next = cur.next;
    cur.next = prev;
    prev = cur;
    cur = next;
}
boolean hasCycle = prev == first && first != null && first.next != null;

// reconstruct the list
cur = prev;
prev = null;
while (cur != null) {
    Node next = cur.next;
    cur.next = prev;
    prev = cur;
    cur = next;
}

return hasCycle;

Testcode:

static void assertSameOrder(Node[] nodes) {
    for (int i = 0; i < nodes.length - 1; i++) {
        assert nodes[i].next == nodes[i + 1];
    }
}

public static void main(String[] args) {
    Node[] nodes = new Node[100];
    for (int i = 0; i < nodes.length; i++) {
        nodes[i] = new Node();
    }
    for (int i = 0; i < nodes.length - 1; i++) {
        nodes[i].next = nodes[i + 1];
    }
    Node first = nodes[0];
    Node max = nodes[nodes.length - 1];

    max.next = null;
    assert !hasCycle(first);
    assertSameOrder(nodes);
    max.next = first;
    assert hasCycle(first);
    assertSameOrder(nodes);
    max.next = max;
    assert hasCycle(first);
    assertSameOrder(nodes);
    max.next = nodes[50];
    assert hasCycle(first);
    assertSameOrder(nodes);
}

Schildkröte und Hase

Schauen Sie sich Pollards Rho-Algorithmus an . Es ist nicht ganz das gleiche Problem, aber vielleicht verstehen Sie die Logik daraus und wenden sie auf verknüpfte Listen an.

(Wenn Sie faul sind, können Sie einfach die Zykluserkennung überprüfen - überprüfen Sie den Teil über die Schildkröte und den Hasen.)

Dies erfordert nur eine lineare Zeit und 2 zusätzliche Zeiger.

In Java:

boolean hasLoop( Node first ) {
    if ( first == null ) return false;

    Node turtle = first;
    Node hare = first;

    while ( hare.next != null && hare.next.next != null ) {
         turtle = turtle.next;
         hare = hare.next.next;

         if ( turtle == hare ) return true;
    }

    return false;
}

(Die meisten Lösungen suchen nicht nach beiden nextund next.nextnach Nullen. Da die Schildkröte immer im Rückstand ist, müssen Sie sie auch nicht auf Null prüfen - der Hase hat das bereits getan.)

Der Benutzer unicornaddict hat oben einen netten Algorithmus, der jedoch leider einen Fehler für nicht-loopy Listen mit ungerader Länge> = 3 enthält. Das Problem ist, dass er fastkurz vor dem Ende der Liste "stecken bleiben" kann, ihn sloweinholt und Eine Schleife wird (fälschlicherweise) erkannt.

Hier ist der korrigierte Algorithmus.

static boolean hasLoop(Node first) {

    if(first == null) // list does not exist..so no loop either.
        return false;

    Node slow, fast; // create two references.

    slow = fast = first; // make both refer to the start of the list.

    while(true) {
        slow = slow.next;          // 1 hop.
        if(fast.next == null)
            fast = null;
        else
            fast = fast.next.next; // 2 hops.

        if(fast == null) // if fast hits null..no loop.
            return false;

        if(slow == fast) // if the two ever meet...we must have a loop.
            return true;
    }
}

In diesem Zusammenhang gibt es überall eine Menge Textmaterialien. Ich wollte nur eine schematische Darstellung veröffentlichen, die mir wirklich geholfen hat, das Konzept zu verstehen.

Wenn sich schnell und langsam am Punkt p treffen,

Zurückgelegte Strecke schnell = a + b + c + b = a + 2b + c

Zurückgelegte Strecke langsam = a + b

Da ist das schnelle 2 mal schneller als das langsame. Also a + 2b + c = 2 (a + b) , dann erhalten wir a = c .

Wenn also wieder ein anderer langsamer Zeiger von Kopf nach q läuft, läuft gleichzeitig ein schneller Zeiger von p nach q , sodass sie sich am Punkt q zusammen treffen .

public ListNode detectCycle(ListNode head) {
    if(head == null || head.next==null)
        return null;

    ListNode slow = head;
    ListNode fast = head;

    while (fast!=null && fast.next!=null){
        fast = fast.next.next;
        slow = slow.next;

        /*
        if the 2 pointers meet, then the 
        dist from the meeting pt to start of loop 
        equals
        dist from head to start of loop
        */
        if (fast == slow){ //loop found
            slow = head;
            while(slow != fast){
                slow = slow.next;
                fast = fast.next;
            }
            return slow;
        }            
    }
    return null;
}

Algorithmus

public static boolean hasCycle (LinkedList<Node> list)
{
    HashSet<Node> visited = new HashSet<Node>();

    for (Node n : list)
    {
        visited.add(n);

        if (visited.contains(n.next))
        {
            return true;
        }
    }

    return false;
}

Komplexität

Time ~ O(n)
Space ~ O(n)

Das Folgende ist möglicherweise nicht die beste Methode - es ist O (n ^ 2). Es sollte jedoch dazu dienen, die Arbeit (irgendwann) zu erledigen.

count_of_elements_so_far = 0;
for (each element in linked list)
{
    search for current element in first <count_of_elements_so_far>
    if found, then you have a loop
    else,count_of_elements_so_far++;
}

public boolean hasLoop(Node start){   
   TreeSet<Node> set = new TreeSet<Node>();
   Node lookingAt = start;

   while (lookingAt.peek() != null){
       lookingAt = lookingAt.next;

       if (set.contains(lookingAt){
           return false;
        } else {
        set.put(lookingAt);
        }

        return true;
}   
// Inside our Node class:        
public Node peek(){
   return this.next;
}

Verzeihen Sie mir meine Unwissenheit (ich bin noch ziemlich neu in Java und Programmierung), aber warum sollte das oben genannte nicht funktionieren?

Ich denke, dies löst nicht das Problem des konstanten Platzbedarfs ... aber es kommt zumindest in angemessener Zeit dort an, richtig? Es wird nur der Platz der verknüpften Liste plus der Platz einer Menge mit n Elementen benötigt (wobei n die Anzahl der Elemente in der verknüpften Liste oder die Anzahl der Elemente ist, bis eine Schleife erreicht ist). Und für die Zeit würde eine Worst-Case-Analyse meiner Meinung nach O (nlog (n)) vorschlagen. SortedSet-Suchvorgänge für enthält () sind log (n) (überprüfen Sie das Javadoc, aber ich bin mir ziemlich sicher, dass die zugrunde liegende Struktur von TreeSet TreeMap ist, dessen wiederum ein rot-schwarzer Baum ist), und im schlimmsten Fall (keine Schleifen, oder Schleife ganz am Ende), es muss n Nachschlagen machen.

Wenn wir die Klasse einbetten dürfen Node, würde ich das Problem lösen, wie ich es unten implementiert habe. hasLoop()läuft in O (n) Zeit und nimmt nur den Raum von counter. Scheint dies eine angemessene Lösung zu sein? Oder gibt es eine Möglichkeit, dies ohne Einbettung zu tun Node? (Offensichtlich würde es in einer realen Implementierung mehr Methoden wie RemoveNode(Node n)usw. geben.)

public class LinkedNodeList {
    Node first;
    Int count;

    LinkedNodeList(){
        first = null;
        count = 0;
    }

    LinkedNodeList(Node n){
        if (n.next != null){
            throw new error("must start with single node!");
        } else {
            first = n;
            count = 1;
        }
    }

    public void addNode(Node n){
        Node lookingAt = first;

        while(lookingAt.next != null){
            lookingAt = lookingAt.next;
        }

        lookingAt.next = n;
        count++;
    }

    public boolean hasLoop(){

        int counter = 0;
        Node lookingAt = first;

        while(lookingAt.next != null){
            counter++;
            if (count < counter){
                return false;
            } else {
               lookingAt = lookingAt.next;
            }
        }

        return true;

    }



    private class Node{
        Node next;
        ....
    }

}

Sie können dies sogar in konstanter O (1) -Zeit tun (obwohl dies nicht sehr schnell oder effizient wäre): Es gibt eine begrenzte Anzahl von Knoten, die der Arbeitsspeicher Ihres Computers aufnehmen kann, beispielsweise N Datensätze. Wenn Sie mehr als N Datensätze durchlaufen, haben Sie eine Schleife.

 // To detect whether a circular loop exists in a linked list
public boolean findCircularLoop() {
    Node slower, faster;
    slower = head;
    faster = head.next; // start faster one node ahead
    while (true) {

        // if the faster pointer encounters a NULL element
        if (faster == null || faster.next == null)
            return false;
        // if faster pointer ever equals slower or faster's next
        // pointer is ever equal to slower then it's a circular list
        else if (slower == faster || slower == faster.next)
            return true;
        else {
            // advance the pointers
            slower = slower.next;
            faster = faster.next.next;
        }
    }
}

boolean hasCycle(Node head) {

    boolean dec = false;
    Node first = head;
    Node sec = head;
    while(first != null && sec != null)
    {
        first = first.next;
        sec = sec.next.next;
        if(first == sec )
        {
            dec = true;
            break;
        }

    }
        return dec;
}

Verwenden Sie die obige Funktion, um eine Schleife in der verknüpften Liste in Java zu erkennen.

Das Erkennen einer Schleife in einer verknüpften Liste kann auf eine der einfachsten Arten erfolgen, was zu einer O (N) -Komplexität unter Verwendung von Hashmap oder O (NlogN) unter Verwendung eines sortierungsbasierten Ansatzes führt.

Erstellen Sie beim Durchlaufen der Liste ab Kopf eine sortierte Adressliste. Wenn Sie eine neue Adresse einfügen, überprüfen Sie, ob die Adresse bereits in der sortierten Liste vorhanden ist, was die Komplexität von O (logN) erfordert.

Ich kann mir keine Möglichkeit vorstellen, dies zeitlich oder räumlich festzuhalten. Beide werden mit der Größe der Liste zunehmen.

Ich würde eine IdentityHashMap verwenden (da es noch kein IdentityHashSet gibt) und jeden Knoten in der Karte speichern. Bevor ein Knoten gespeichert wird, würden Sie includesKey darauf aufrufen. Wenn der Knoten bereits vorhanden ist, haben Sie einen Zyklus.

ItentityHashMap verwendet == anstelle von .equals, damit Sie überprüfen, wo sich das Objekt im Speicher befindet, und nicht, ob es denselben Inhalt hat.

Ich könnte furchtbar spät und neu sein, um diesen Thread zu bearbeiten. Aber dennoch..

Warum kann die Adresse des Knotens und des "nächsten" Knotens, auf den gezeigt wird, nicht in einer Tabelle gespeichert werden?

Wenn wir so tabellieren könnten

node present: (present node addr) (next node address)

node 1: addr1: 0x100 addr2: 0x200 ( no present node address till this point had 0x200)
node 2: addr2: 0x200 addr3: 0x300 ( no present node address till this point had 0x300)
node 3: addr3: 0x300 addr4: 0x400 ( no present node address till this point had 0x400)
node 4: addr4: 0x400 addr5: 0x500 ( no present node address till this point had 0x500)
node 5: addr5: 0x500 addr6: 0x600 ( no present node address till this point had 0x600)
node 6: addr6: 0x600 addr4: 0x400 ( ONE present node address till this point had 0x400)

Daher wird ein Zyklus gebildet.

Hier ist mein ausführbarer Code.

Was ich getan habe, ist, die verknüpfte Liste mithilfe von drei temporären Knoten (Raumkomplexität O(1)) zu verehren, die die Verknüpfungen verfolgen.

Die interessante Tatsache dabei ist, den Zyklus in der verknüpften Liste zu erkennen, da Sie im weiteren Verlauf nicht erwarten, zum Startpunkt (Wurzelknoten) zurückzukehren, und einer der temporären Knoten sollte auf Null gehen, es sei denn, Sie einen Zyklus haben, der auf den Wurzelknoten zeigt.

Die zeitliche Komplexität dieses Algorithmus ist O(n)und die räumliche Komplexität ist O(1).

Hier ist der Klassenknoten für die verknüpfte Liste:

public class LinkedNode{
    public LinkedNode next;
}

Hier ist der Hauptcode mit einem einfachen Testfall von drei Knoten, wobei der letzte Knoten auf den zweiten Knoten zeigt:

    public static boolean checkLoopInLinkedList(LinkedNode root){

        if (root == null || root.next == null) return false;

        LinkedNode current1 = root, current2 = root.next, current3 = root.next.next;
        root.next = null;
        current2.next = current1;

        while(current3 != null){
            if(current3 == root) return true;

            current1 = current2;
            current2 = current3;
            current3 = current3.next;

            current2.next = current1;
        }
        return false;
    }

Hier ist ein einfacher Testfall von drei Knoten, bei denen der letzte Knoten auf den zweiten Knoten zeigt:

public class questions{
    public static void main(String [] args){

        LinkedNode n1 = new LinkedNode();
        LinkedNode n2 = new LinkedNode();
        LinkedNode n3 = new LinkedNode();
        n1.next = n2;
        n2.next = n3;
        n3.next = n2;

        System.out.print(checkLoopInLinkedList(n1));
    }
}

Dieser Code ist optimiert und liefert ein schnelleres Ergebnis als der als beste Antwort ausgewählte. Dieser Code erspart Ihnen einen sehr langen Prozess des Verfolgens des Vorwärts- und Rückwärtsknotenzeigers, der im folgenden Fall auftritt, wenn wir dem Besten folgen Antwort 'Methode. Schauen Sie sich den Trockenlauf der folgenden an und Sie werden erkennen, was ich zu sagen versuche. Dann schauen Sie sich das Problem mit der unten angegebenen Methode an und messen Sie die Nr. von Schritten unternommen, um die Antwort zu finden.

1-> 2-> 9-> 3 ^ -------- ^

Hier ist der Code:

boolean loop(node *head)
{
 node *back=head;
 node *front=head;

 while(front && front->next)
 {
  front=front->next->next;
  if(back==front)
  return true;
  else
  back=back->next;
 }
return false
}

Hier ist meine Lösung in Java

boolean detectLoop(Node head){
    Node fastRunner = head;
    Node slowRunner = head;
    while(fastRunner != null && slowRunner !=null && fastRunner.next != null){
        fastRunner = fastRunner.next.next;
        slowRunner = slowRunner.next;
        if(fastRunner == slowRunner){
            return true;
        }
    }
    return false;
}

Sie können auch Floyds Schildkrötenalgorithmus verwenden, wie in den obigen Antworten vorgeschlagen.

Dieser Algorithmus kann prüfen, ob eine einfach verknüpfte Liste einen geschlossenen Zyklus hat. Dies kann erreicht werden, indem eine Liste mit zwei Zeigern iteriert wird, die sich mit unterschiedlicher Geschwindigkeit bewegen. Auf diese Weise treffen sich die beiden Zeiger bei einem Zyklus irgendwann in der Zukunft.

Bitte schauen Sie sich meinen Blog-Beitrag in der Datenstruktur der verknüpften Listen an, in dem ich auch ein Code-Snippet mit einer Implementierung des oben genannten Algorithmus in Java-Sprache eingefügt habe.

Grüße,

Andreas (@xnorcode)

Hier ist die Lösung zur Erkennung des Zyklus.

public boolean hasCycle(ListNode head) {
            ListNode slow =head;
            ListNode fast =head;

            while(fast!=null && fast.next!=null){
                slow = slow.next; // slow pointer only one hop
                fast = fast.next.next; // fast pointer two hops 

                if(slow == fast)    return true; // retrun true if fast meet slow pointer
            }

            return false; // return false if fast pointer stop at end 
        }

// Verknüpfungsfunktion für verknüpfte Listen finden

int findLoop(struct Node* head)
{
    struct Node* slow = head, *fast = head;
    while(slow && fast && fast->next)
    {
        slow = slow->next;
        fast = fast->next->next;
        if(slow == fast)
            return 1;
    }
 return 0;
}

Dieser Ansatz hat Platzbedarf, aber eine einfachere Implementierung:

Die Schleife kann durch Speichern von Knoten in einer Karte identifiziert werden. Und bevor Sie den Knoten setzen; Überprüfen Sie, ob der Knoten bereits vorhanden ist. Wenn der Knoten bereits in der Karte vorhanden ist, bedeutet dies, dass die verknüpfte Liste eine Schleife hat.

public boolean loopDetector(Node<E> first) {  
       Node<E> t = first;  
       Map<Node<E>, Node<E>> map = new IdentityHashMap<Node<E>, Node<E>>();  
       while (t != null) {  
            if (map.containsKey(t)) {  
                 System.out.println(" duplicate Node is --" + t  
                           + " having value :" + t.data);  

                 return true;  
            } else {  
                 map.put(t, t);  
            }  
            t = t.next;  
       }  
       return false;  
  }  

public boolean isCircular() {

    if (head == null)
        return false;

    Node temp1 = head;
    Node temp2 = head;

    try {
        while (temp2.next != null) {

            temp2 = temp2.next.next.next;
            temp1 = temp1.next;

            if (temp1 == temp2 || temp1 == temp2.next) 
                return true;    

        }
    } catch (NullPointerException ex) {
        return false;

    }

    return false;

}