Làm thế nào để phát hiện một vòng lặp trong danh sách liên kết?

Giả sử bạn có cấu trúc danh sách được liên kết trong Java. Nó được tạo thành từ các nút:

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

và mỗi nút chỉ đến nút tiếp theo, ngoại trừ nút cuối cùng, có giá trị null cho tiếp theo. Giả sử có khả năng danh sách có thể chứa một vòng lặp - tức là Nút cuối cùng, thay vì có null, có một tham chiếu đến một trong các nút trong danh sách đi trước nó.

Cách viết tốt nhất

boolean hasLoop(Node first)

cái nào sẽ trả về truenếu Node đã cho là đầu tiên của danh sách có vòng lặp, và falsengược lại? Làm thế nào bạn có thể viết để nó cần một không gian cố định và một khoảng thời gian hợp lý?

Đây là hình ảnh của một danh sách với một vòng lặp trông như thế nào:

Bạn có thể sử dụng thuật toán tìm chu kỳ của Floyd , còn được gọi là thuật toán rùa và thỏ .

Ý tưởng là có hai tham chiếu đến danh sách và di chuyển chúng ở các tốc độ khác nhau . Di chuyển một chuyển tiếp bởi 1nút và khác bởi 2các nút.

• Nếu danh sách liên kết có một vòng lặp chắc chắn họ sẽ gặp nhau.
• Khác một trong hai tài liệu tham khảo (hoặc của họ next) sẽ trở thành null.

Hàm Java thực hiện thuật toán:

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

Đây là một sàng lọc của giải pháp Nhanh / Chậm, xử lý chính xác các danh sách độ dài lẻ và cải thiện độ rõ ràng.

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
}

Tốt hơn thuật toán của Floyd

Richard Brent đã mô tả một thuật toán phát hiện chu kỳ thay thế , khá giống với thỏ và rùa [chu kỳ của Floyd] ngoại trừ, nút chậm ở đây không di chuyển, nhưng sau đó được "dịch chuyển" đến vị trí của nút nhanh khi cố định khoảng thời gian.

Mô tả có sẵn ở đây: http://www.siafoo.net/alacticm/11 Brent tuyên bố rằng thuật toán của anh ta nhanh hơn 24 đến 36% so với thuật toán chu kỳ của Floyd. Độ phức tạp thời gian O (n), độ phức tạp không gian O (1).

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

Một giải pháp thay thế cho Rùa và Thỏ, không hoàn toàn tốt đẹp, vì tôi tạm thời thay đổi danh sách:

Ý tưởng là đi bộ danh sách, và đảo ngược nó khi bạn đi. Sau đó, khi bạn lần đầu tiên tiếp cận một nút đã được truy cập, con trỏ tiếp theo của nó sẽ trỏ "ngược", khiến việc lặp lại tiếp tục tiến về phía trước first, nơi nó kết thúc.

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;

Mã kiểm tra:

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

Rùa và thỏ

Hãy xem thuật toán rho của Pollard . Đây không phải là vấn đề hoàn toàn giống nhau, nhưng có lẽ bạn sẽ hiểu logic từ nó và áp dụng nó cho các danh sách được liên kết.

(nếu bạn lười biếng, bạn có thể kiểm tra phát hiện chu kỳ - kiểm tra phần về rùa và thỏ.)

Điều này chỉ yêu cầu thời gian tuyến tính, và 2 con trỏ thêm.

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

(Hầu hết các giải pháp không kiểm tra cả hai nextvà next.nextcho null. Ngoài ra, vì con rùa luôn ở phía sau, bạn không phải kiểm tra nó cho null - thỏ đã làm điều đó rồi.)

Người dùng unicornaddict có một thuật toán đẹp ở trên, nhưng thật không may, nó có một lỗi cho các danh sách không có bản đồ có độ dài lẻ> = 3. Vấn đề là fastcó thể bị "kẹt" ngay trước khi kết thúc danh sách,slow bắt kịp nó và một vòng lặp (sai) được phát hiện.

Đây là thuật toán đã sửa.

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

Trong bối cảnh này, có rất nhiều tài liệu văn bản ở khắp mọi nơi. Tôi chỉ muốn đăng một đại diện sơ đồ thực sự giúp tôi nắm bắt được khái niệm.

Khi nhanh và chậm gặp nhau tại điểm p,

Quãng đường đi được nhanh = a + b + c + b = a + 2b + c

Quãng đường đi chậm = a + b

Vì nhanh là nhanh gấp 2 lần so với chậm. Vậy a + 2b + c = 2 (a + b) , sau đó ta được a = c .

Vì vậy, khi một con trỏ chậm khác chạy lại từ đầu đến q , đồng thời, con trỏ nhanh sẽ chạy từ p đến q , vì vậy chúng gặp nhau tại điểm q cùng nhau.

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

Thuật toán

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

Phức tạp

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

Sau đây có thể không phải là phương pháp tốt nhất - đó là O (n ^ 2). Tuy nhiên, nó sẽ phục vụ để hoàn thành công việc (cuối cùng).

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

Hãy tha thứ cho tôi về sự thiếu hiểu biết của tôi (tôi vẫn còn khá mới đối với Java và lập trình), nhưng tại sao các công việc trên không hoạt động?

Tôi đoán điều này không giải quyết được vấn đề không gian liên tục ... nhưng ít nhất nó sẽ đến đó trong một thời gian hợp lý, đúng không? Nó sẽ chỉ lấy không gian của danh sách được liên kết cộng với không gian của một tập hợp có n phần tử (trong đó n là số phần tử trong danh sách được liên kết hoặc số phần tử cho đến khi đạt đến một vòng lặp). Và theo thời gian, phân tích trường hợp xấu nhất, tôi nghĩ, sẽ đề xuất O (nlog (n)). Các tra cứu được sắp xếp để chứa () là log (n) (kiểm tra javadoc, nhưng tôi khá chắc chắn cấu trúc cơ bản của TreeSet là TreeMap, trong đó lần lượt là một cây màu đỏ đen) và trong trường hợp xấu nhất (không có vòng lặp, hoặc lặp ở cuối), nó sẽ phải thực hiện n tra cứu.

Nếu chúng tôi được phép nhúng lớp Node, tôi sẽ giải quyết vấn đề khi tôi triển khai nó bên dưới. hasLoop()chạy trong thời gian O (n) và chỉ chiếm không gian của counter. Điều này có vẻ như là một giải pháp thích hợp? Hoặc có một cách để làm điều đó mà không nhúng Node? (Rõ ràng, trong một triển khai thực tế, sẽ có nhiều phương thức hơn, như RemoveNode(Node n), v.v.)

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

}

Bạn thậm chí có thể làm điều đó trong thời gian O (1) không đổi (mặc dù nó sẽ không nhanh hoặc hiệu quả): Có một số lượng hạn chế các nút mà bộ nhớ máy tính của bạn có thể giữ, nói N bản ghi. Nếu bạn duyệt nhiều hơn N bản ghi, thì bạn có một vòng lặp.

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

Sử dụng chức năng trên để phát hiện một vòng lặp trong danh sách liên kết trong java.

Việc phát hiện một vòng lặp trong danh sách được liên kết có thể được thực hiện theo một trong những cách đơn giản nhất, dẫn đến độ phức tạp O (N) bằng cách sử dụng hàm băm hoặc O (NlogN) bằng cách sử dụng phương pháp sắp xếp.

Khi bạn duyệt qua danh sách bắt đầu từ đầu, hãy tạo một danh sách địa chỉ được sắp xếp. Khi bạn chèn một địa chỉ mới, hãy kiểm tra xem địa chỉ đó đã có trong danh sách đã sắp xếp chưa, có độ phức tạp O (logN) không.

Tôi không thể thấy bất kỳ cách nào để thực hiện việc này mất một khoảng thời gian hoặc không gian cố định, cả hai sẽ tăng theo kích thước của danh sách.

Tôi sẽ sử dụng một IdentityHashMap (với điều kiện là chưa có IdentityHashset) và lưu trữ mỗi Node vào bản đồ. Trước khi một nút được lưu trữ, bạn sẽ gọi chứaKeyKey trên đó. Nếu Node đã tồn tại, bạn có một chu kỳ.

ItentityHashMap sử dụng == thay vì .equals để bạn kiểm tra vị trí của đối tượng trong bộ nhớ thay vì nếu nó có cùng nội dung.

Tôi có thể rất muộn và mới để xử lý chủ đề này. Nhưng vẫn..

Tại sao không thể lưu địa chỉ của nút và nút "tiếp theo" được lưu trữ trong bảng

Nếu chúng ta có thể lập bảng theo cách này

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)

Do đó có một chu kỳ hình thành.

Đây là mã runnable của tôi.

Những gì tôi đã làm là hoàn nguyên danh sách được liên kết bằng cách sử dụng ba nút tạm thời (độ phức tạp không gian O(1)) để theo dõi các liên kết.

Thực tế thú vị khi thực hiện là giúp phát hiện chu trình trong danh sách được liên kết bởi vì khi bạn tiếp tục, bạn không mong đợi quay lại điểm bắt đầu (nút gốc) và một trong các nút tạm thời sẽ chuyển sang null trừ khi bạn có một chu kỳ có nghĩa là nó trỏ đến nút gốc.

Độ phức tạp thời gian của thuật toán này là O(n)và độ phức tạp không gian là O(1).

Đây là nút lớp cho danh sách được liên kết:

public class LinkedNode{
    public LinkedNode next;
}

Đây là mã chính với trường hợp kiểm tra đơn giản gồm ba nút mà nút cuối cùng trỏ đến nút thứ hai:

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

Đây là trường hợp thử nghiệm đơn giản gồm ba nút mà nút cuối cùng trỏ đến nút thứ hai:

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

Mã này được tối ưu hóa và sẽ tạo ra kết quả nhanh hơn so với câu được chọn là câu trả lời đúng nhất. Mã này tiết kiệm từ việc đi vào một quá trình rất dài để theo đuổi con trỏ nút tiến và lùi sẽ xảy ra trong trường hợp sau nếu chúng ta làm theo 'tốt nhất Trả lời 'phương pháp. Xem qua các bước sau đây và bạn sẽ nhận ra điều tôi đang cố gắng nói. Sau đó, hãy xem xét vấn đề thông qua phương pháp đã cho bên dưới và đo lường không. các bước thực hiện để tìm câu trả lời.

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

Đây là mã:

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
}

Đây là giải pháp của tôi trong 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;
}

Bạn cũng có thể sử dụng thuật toán rùa của Floyd như được đề xuất trong các câu trả lời ở trên.

Thuật toán này có thể kiểm tra xem một danh sách liên kết đơn có chu trình kín không. Điều này có thể đạt được bằng cách lặp lại một danh sách với hai con trỏ sẽ di chuyển ở tốc độ khác nhau. Theo cách này, nếu có một chu kỳ, hai con trỏ sẽ gặp nhau tại một thời điểm nào đó trong tương lai.

Xin vui lòng kiểm tra bài đăng trên blog của tôi trên cấu trúc dữ liệu danh sách được liên kết, trong đó tôi cũng bao gồm một đoạn mã với việc thực hiện thuật toán được đề cập ở trên trong ngôn ngữ java.

Trân trọng,

Andreas (@xnorcode)

Đây là giải pháp để phát hiện chu kỳ.

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 
        }

// danh sách liên kết tìm chức năng lặp

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

Cách tiếp cận này có không gian trên không, nhưng thực hiện đơn giản hơn:

Vòng lặp có thể được xác định bằng cách lưu trữ các nút trong Bản đồ. Và trước khi đặt nút; kiểm tra xem nút đã tồn tại chưa. Nếu nút đã tồn tại trong bản đồ thì có nghĩa là Danh sách liên kết có vòng lặp.

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;

}