Bağlantılı listedeki bir döngü nasıl algılanır?

Diyelim ki Java'da bağlantılı bir liste yapınız var. Düğümlerden oluşur:

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

ve her bir düğüm, bir sonraki için boş olan son Düğüm hariç, bir sonraki düğüme işaret eder. Listenin bir döngü içerebilme olasılığı olduğunu varsayalım; yani son Düğüm, bir boş değere sahip olmak yerine, listedeki düğümlerden birine başvuruda bulunuyor.

Yazmanın en iyi yolu nedir

boolean hasLoop(Node first)

trueverilen Düğüm bir döngüye sahip bir listenin ilki ise hangisi dönecektir false? Nasıl sabit bir alan ve makul bir zaman gerektirecek şekilde yazabilirsiniz?

Döngü içeren bir listenin neye benzediğini gösteren bir resim:

Floyd'un kaplumbağa ve tavşan algoritması olarak da bilinen döngü bulma algoritmasını kullanabilirsiniz .

Fikir, listeye iki referans vermek ve bunları farklı hızlarda taşımaktır . Birini 1düğüm ve diğerini 2düğümlerle ilerletin .

• Bağlantılı listenin bir döngüsü varsa, kesinlikle karşılarlar.
• Diğer iki referanstan biri (ya da onların next) olur null.

Algoritmayı uygulayan Java işlevi:

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;
    }
}

Burada, garip uzunluk listelerini doğru şekilde işleyen ve netliği artıran Hızlı / Yavaş çözümünün iyileştirilmesi.

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
}

Floyd'un algoritmasından daha iyi

Richard Brent alternatif bir döngü algılama algoritması tanımladı , tavşan ve kaplumbağaya (Floyd'un döngüsü) benzeyen , ancak buradaki yavaş düğüm hareket etmiyor, ancak daha sonra sabit düğümdeki hızlı düğüm konumuna "ışınlanıyor" aralıkları.

Açıklama burada bulunabilir: http://www.siafoo.net/algorithm/11 Brent algoritmasının Floyd'un döngü algoritmasından% 24 ila 36 daha hızlı olduğunu iddia ediyor. O (n) zaman karmaşıklığı, O (1) uzay karmaşıklığı.

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;
}

Listeyi geçici olarak değiştirdiğim kadar güzel değil, Kaplumbağa ve Tavşan için alternatif bir çözüm:

Fikir, listeyi yürümek ve gittikçe tersine çevirmektir. Ardından, daha önce ziyaret edilmiş bir düğüme ilk ulaştığınızda, bir sonraki işaretçisi "geriye" işaret edecek ve yinelemenin firstsona erdiği yere tekrar ilerlemesine neden olacaktır .

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;

Test kodu:

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);
}

Kaplumbağa ve tavşan

Pollard'ın rho algoritmasına bir göz atın . Aynı sorun değil, ama belki de mantığı ondan anlayacak ve bağlantılı listelere uygulayacaksınız.

(tembelseniz, döngü algılamasını kontrol edebilirsiniz. - kaplumbağa ve tavşan hakkındaki bölümü kontrol edin.)

Bu sadece doğrusal zaman ve 2 ekstra işaretçi gerektirir.

Java dilinde:

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;
}

(Solüsyonlarının çoğu ikisi için kontrol etmiyoruz nextve next.nextiçin boş değerlere Ayrıca kaplumbağa arkasında daima olduğundan, size boş olup olmadığını kontrol etmek gerekmez -.. Tavşan zaten bunu yaptı)

Kullanıcı unicornaddict yukarıda güzel bir algoritma var, ama maalesef garip uzunluk> = 3 döngüsel olmayan listeler için bir hata içerir. Sorun, fastlistenin sonundan hemen önce "sıkışmış" alabilirsinizslow , o kadar yakalar ve bir döngü (yanlış) tespit edildi.

İşte düzeltilmiş algoritma.

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;
    }
}

Bu bağlamda, her yerde metin materyallerine yükler vardır. Sadece konsepti anlamamda bana yardımcı olan diyagramatik bir sunum yapmak istedim.

Hızlı ve yavaş p noktasında buluştuğunda,

Hızlı gidilen mesafe = a + b + c + b = a + 2b + c

Yavaş hareket mesafesi = a + b

Çünkü hızlı yavaştan 2 kat daha hızlıdır. Yani a + 2b + c = 2 (a + b) , sonra a = c elde ederiz .

Bu nedenle, başka bir yavaş işaretçi baştan başa tekrar çalıştığında , aynı zamanda hızlı işaretçi p'den q'ya koşar , böylece q noktasında bir araya gelirler.

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;
}

Algoritma

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;
}

karmaşa

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

Aşağıdakiler en iyi yöntem olmayabilir - O (n ^ 2). Bununla birlikte, işi bitirmeye hizmet etmelidir (sonunda).

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;
}

Cehaletimi affet (Java ve programlama konusunda hala yeniyim), ama yukarıdakiler neden işe yaramasın ki?

Sanırım bu sürekli uzay sorununu çözmüyor ... ama en azından oraya makul bir zamanda var, değil mi? Yalnızca bağlantılı listenin alanını artı n öğeli bir kümenin alanını alır (burada n, bağlantılı listedeki öğelerin sayısı veya bir döngüye ulaşana kadar öğe sayısıdır). Ve zamanla, en kötü durum analizi, sanırım O (nlog (n)) önerir. İnclude () için SortedSet aramaları log (n) (javadoc'u kontrol edin, ancak TreeSet'in altında yatan yapının TreeMap olduğundan eminim ki bu da kırmızı-siyah bir ağaçtır) ve en kötü durumda (döngüler, veya sonda döngü), n-up yapmak zorunda kalacak.

Sınıfı gömmemize izin verilirse Node, sorunu aşağıda uyguladığım şekilde çözerdim. hasLoop()O (n) zamanda çalışır ve sadece boşluğunu alır counter. Bu uygun bir çözüm gibi mi görünüyor? Yoksa gömmeden yapmanın bir yolu var Nodemı? (Açıkçası, gerçek bir uygulamada RemoveNode(Node n), vb. Gibi daha fazla yöntem olacaktır .)

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;
        ....
    }

}

Bunu sabit O (1) zamanda bile yapabilirsiniz (çok hızlı veya verimli olmasa da): Bilgisayarınızın belleğinin tutabileceği sınırlı sayıda düğüm var, örneğin N kayıtları. N'den fazla kayıt geçirirseniz, bir döngünüz vardır.

 // 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;
}

Java bağlantılı listesinde bir döngü algılamak için yukarıdaki işlevi kullanın.

Bağlantılı bir listedeki bir döngüyü tespit etmek en basit yollardan biriyle yapılabilir, bu da sıralama tabanlı bir yaklaşım kullanarak hashmap veya O (NlogN) kullanarak O (N) karmaşıklığına yol açar.

Listeyi baştan başa doğru hareket ettirdikçe, sıralı bir adres listesi oluşturun. Yeni bir adres eklediğinizde, adresin zaten sıralanmış listede O (logN) karmaşıklığı olup olmadığını kontrol edin.

Bunu sabit bir süre veya alan kaplamanın herhangi bir yolunu göremiyorum, her ikisi de listenin boyutuyla artacak.

(Henüz bir IdentityHashSet olmadığı göz önüne alındığında) bir IdentityHashMap kullanırım ve her düğümü haritaya kaydederim. Bir düğüm kaydedilmeden önce üzerinde ihtiva anahtarını çağırırsınız. Düğüm zaten varsa bir döngünüz vardır.

ItentityHashMap .equals yerine == kullanır, böylece nesnenin aynı içeriğe sahip olması yerine bellekte nerede olduğunu kontrol edersiniz.

Bu konuyu ele almak için çok geç ve yeni olabilirim. Ama hala..

Düğümün adresi ve işaret eden "sonraki" düğüm neden bir tabloda saklanamıyor?

Bu şekilde tablolaştırabilseydik

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)

Dolayısıyla bir döngü oluşur.

İşte benim çalıştırılabilir kodum.

Ne yaptım bağlantıları takip üç geçici düğüm (boşluk karmaşıklığı O(1)) kullanarak bağlı liste geri almaktır .

Bunu yapmakla ilgili ilginç gerçek, bağlantılı listedeki döngüyü algılamaya yardımcı olmaktır, çünkü ilerledikçe, başlangıç ​​noktasına (kök düğüm) geri dönmeyi beklemezsiniz ve geçici düğümlerden biri, siz sürece sürece null değerine gitmelidir. Kök düğümü işaret ettiği bir döngü var.

Bu algoritmanın zaman karmaşıklığı O(n)ve uzay karmaşıklığıdır O(1).

Bağlantılı listenin sınıf düğümü:

public class LinkedNode{
    public LinkedNode next;
}

Son düğümün ikinci düğüme işaret ettiği üç düğümden oluşan basit bir test senaryosuna sahip ana kod:

    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;
    }

Son düğümün ikinci düğüme işaret ettiği üç düğümden oluşan basit bir test örneği:

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));
    }
}

Bu kod optimize edilmiştir ve en iyi yanıt olarak seçilen koddan daha hızlı sonuç verecektir. cevap 'yöntemi. aşağıdaki kuru çalışma bakmak ve ne söylemeye çalışacağımı fark edeceksiniz. sonra aşağıdaki verilen yöntem ile soruna bakmak ve no ölçmek. cevabı bulmak için atılan adımlar.

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

İşte kod:

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
}

İşte benim java çözüm

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;
}

Floyd'un kaplumbağa algoritmasını yukarıdaki cevaplarda da önerildiği gibi kullanabilirsiniz.

Bu algoritma, tek bağlantılı bir listenin kapalı bir döngüye sahip olup olmadığını kontrol edebilir. Bu, farklı hızda hareket edecek iki işaretçi içeren bir listeyi yineleyerek elde edilebilir. Bu şekilde, bir döngü varsa, iki işaretçi gelecekte bir noktada buluşacaktır.

Lütfen java dilinde yukarıda belirtilen algoritmanın bir uygulamasına sahip bir kod snippet'i eklediğim bağlantılı listeler veri yapısında blog yayınımı kontrol etmekten çekinmeyin .

Saygılarımızla,

Andreas (@xnorcode) Instagram Profilini Görüntüle

Döngüyü tespit etmek için çözüm.

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 
        }

// bağlantılı liste bul döngü işlevi

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;
}

Bu yaklaşımın alan yükü vardır, ancak daha basit bir uygulaması vardır:

Döngü, düğümleri bir Haritaya kaydederek tanımlanabilir. Ve düğümü koymadan önce; düğümün zaten mevcut olup olmadığını kontrol edin. Haritada düğüm zaten varsa Bağlantılı Liste'nin döngü olduğu anlamına gelir.

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;

}