จะตรวจจับลูปในรายการที่เชื่อมโยงได้อย่างไร?

สมมติว่าคุณมีโครงสร้างรายการเชื่อมโยงใน Java มันประกอบไปด้วยโหนด:

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

และแต่ละโหนดชี้ไปที่โหนดถัดไปยกเว้นโหนดสุดท้ายซึ่งมีค่า null สำหรับถัดไป สมมติว่ามีความเป็นไปได้ที่รายการสามารถมีลูป - เช่นโหนดสุดท้ายแทนการมีค่า null มีการอ้างอิงถึงหนึ่งในโหนดในรายการที่มาก่อนมัน

เป็นวิธีที่ดีที่สุดในการเขียนอะไร

boolean hasLoop(Node first)

ซึ่งจะกลับมาtrueถ้าโหนดที่กำหนดเป็นคนแรกของรายการที่มีวงและfalseอื่น ๆ ? คุณจะเขียนอย่างไรเพื่อให้มีเนื้อที่คงที่และใช้เวลาพอสมควร

นี่คือภาพของรายการที่มีลักษณะเป็นวง:

คุณสามารถทำให้การใช้งานของอัลกอริทึมวงจรการค้นพบของฟลอยด์ยังเป็นที่รู้จักเต่าและอัลกอริทึมกระต่าย

ความคิดที่จะมีการอ้างอิงถึงสองรายการและย้ายไปที่ความเร็วที่แตกต่างกัน ย้ายไปข้างหน้าหนึ่ง1โหนดและอีก2โหนดหนึ่ง

• หากรายการที่เชื่อมโยงมีการวนซ้ำพวกเขาจะได้พบกันอย่างแน่นอน
• อื่นทั้งสองอ้างอิง (หรือของพวกเขาnext) nullจะกลายเป็น

ฟังก์ชั่น Java ใช้อัลกอริทึม:

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

นี่คือการปรับแต่งโซลูชัน Fast / Slow ซึ่งจัดการรายการความยาวคี่ได้อย่างถูกต้องและปรับปรุงความชัดเจน

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
}

ดีกว่าอัลกอริธึมของฟลอยด์

Richard Brent อธิบายอัลกอริธึมการตรวจหาวัฏจักรทางเลือกซึ่งค่อนข้างเหมือนกระต่ายและเต่า [วงจรของ Floyd] ยกเว้นว่าโหนดช้าที่นี่ไม่เคลื่อนที่ แต่ต่อมา "หายตัว" ไปยังตำแหน่งของโหนดรวดเร็วที่คงที่ ช่วงเวลา

คำอธิบายมีอยู่ที่นี่: http://www.siafoo.net/algorithm/11 เบรนต์อ้างว่าอัลกอริธึมของเขาเร็วกว่าอัลกอริธึมรอบของฟลอยด์ 24 ถึง 36% ความซับซ้อนของเวลา O (n) ความซับซ้อนของพื้นที่ 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;
}

ทางเลือกอื่นสำหรับ Turtle and Rabbit ซึ่งไม่ค่อยดีเท่าที่ฉันเปลี่ยนรายการชั่วคราว:

ความคิดคือการเดินรายการและย้อนกลับในขณะที่คุณไป จากนั้นเมื่อคุณไปถึงโหนดแรกที่มีการเยี่ยมชมแล้วตัวชี้ถัดไปของมันจะชี้ไปที่ "ย้อนกลับ" ทำให้การวนซ้ำดำเนินต่อไปfirstอีกครั้งโดยที่จุดสิ้นสุดนั้น

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;

รหัสทดสอบ:

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

เต่าและกระต่าย

ดูอัลกอริทึม Rho ของ Pollardอัลกอริทึมของโรพอลลาร์ไม่ใช่ปัญหาเดียวกัน แต่บางทีคุณอาจเข้าใจตรรกะจากมันและนำไปใช้กับรายการที่ลิงก์

(หากคุณขี้เกียจคุณสามารถตรวจสอบวงจรการตรวจสอบ - ตรวจสอบส่วนที่เกี่ยวกับเต่าและกระต่าย)

ใช้เวลาเชิงเส้นและตัวชี้พิเศษ 2 ตัวเท่านั้น

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

(วิธีการแก้ปัญหาส่วนใหญ่ไม่ได้ตรวจสอบทั้งสำหรับnextและnext.nextโมฆะนอกจากนี้เนื่องจากเต่าอยู่ด้านหลังเสมอคุณไม่ต้องตรวจสอบเพื่อหา null - กระต่ายทำอย่างนั้นแล้ว)

ผู้ใช้unicornaddictมีอัลกอริทึมที่ดีข้างต้น แต่น่าเสียดายที่มันมีข้อผิดพลาดสำหรับรายการที่ไม่มีการวนซ้ำของความยาวคี่> = 3 ปัญหาคือfastสามารถติด "อยู่" ก่อนสิ้นสุดรายการslowจับได้และ ตรวจพบลูป (ผิด)

นี่คืออัลกอริทึมที่ถูกต้อง

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

ในบริบทนี้มีการโหลดไปยังเนื้อหาต้นฉบับทุกที่ ฉันแค่ต้องการโพสต์การแสดงแผนภาพที่ช่วยให้ฉันเข้าใจแนวคิด

เมื่อพบกันอย่างรวดเร็วและช้า ณ จุด p

ระยะทางเดินทางโดยเร็ว = a + b + c + b = a + 2b + c

ระยะทางเดินทางโดยช้า = a + b

เนื่องจากความเร็วนั้นเร็วกว่าช้ากว่าถึง 2 เท่า ดังนั้นA + 2b + c = 2 (A + B)แล้วเราได้รับA = C

ดังนั้นเมื่อตัวชี้แบบช้าอื่นวิ่งอีกครั้งจากหัวถึง qในเวลาเดียวกันตัวชี้แบบเร็วจะทำงานจากp ถึง qดังนั้นพวกเขาจึงพบกันที่จุดqด้วยกัน

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

ขั้นตอนวิธี

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

ความซับซ้อน

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

ต่อไปนี้อาจไม่ใช่วิธีที่ดีที่สุด - เป็น O (n ^ 2) อย่างไรก็ตามควรให้บริการเพื่อให้งานเสร็จ (ในที่สุด)

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

ให้อภัยฉันไม่รู้ (ฉันยังค่อนข้างใหม่กับ Java และการเขียนโปรแกรม) แต่ทำไมจะไม่ทำงานข้างต้น

ฉันเดาว่านี่จะไม่ช่วยแก้ปัญหาเรื่องพื้นที่คงที่ ... แต่อย่างน้อยในเวลาที่เหมาะสม มันจะใช้พื้นที่ของรายการที่เชื่อมโยงรวมถึงพื้นที่ของชุดที่มีองค์ประกอบ n (โดยที่ n คือจำนวนองค์ประกอบในรายการที่เชื่อมโยงหรือจำนวนองค์ประกอบจนกว่าจะถึงวง) และสำหรับเวลาการวิเคราะห์กรณีที่เลวร้ายที่สุดฉันคิดว่าจะแนะนำ O (nlog (n)) SortedSet การค้นหาสำหรับ contain () เป็น log (n) (ตรวจสอบ javadoc แต่ฉันค่อนข้างแน่ใจว่าโครงสร้างพื้นฐานของ TreeSet คือ TreeMap ซึ่งเป็นต้นไม้สีแดงดำ) และในกรณีที่แย่ที่สุด (ไม่มีลูป หรือวนที่ปลายสุด) จะต้องค้นหา

หากเราได้รับอนุญาตให้ฝังชั้นเรียนNodeฉันจะแก้ปัญหาตามที่ฉันใช้งานด้านล่าง hasLoop()วิ่งใน O (n) counterเวลาและใช้เวลาเพียงพื้นที่ของ สิ่งนี้ดูเหมือนจะเป็นทางออกที่เหมาะสมหรือไม่? หรือมีวิธีที่จะทำโดยไม่ฝังNode? (เห็นได้ชัดว่าในการใช้งานจริงจะมีวิธีการมากขึ้นเช่นRemoveNode(Node n)ฯลฯ )

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

}

คุณสามารถทำได้แม้ในเวลา O (1) คงที่ (แม้ว่าจะไม่เร็วมากหรือมีประสิทธิภาพ): มีจำนวน จำกัด ของโหนดที่หน่วยความจำของคอมพิวเตอร์ของคุณสามารถเก็บได้กล่าว N บันทึก หากคุณสำรวจมากกว่า N บันทึกคุณจะมีลูป

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

การตรวจจับลูปในรายการที่ลิงก์สามารถทำได้ด้วยวิธีใดวิธีหนึ่งที่ง่ายที่สุดซึ่งส่งผลให้เกิดความซับซ้อน O (N) โดยใช้ hashmap หรือ O (NlogN) โดยใช้วิธีการเรียงลำดับ

เมื่อคุณสำรวจรายการที่เริ่มต้นจากส่วนหัวให้สร้างรายการที่อยู่ที่เรียงลำดับแล้ว เมื่อคุณแทรกที่อยู่ใหม่ให้ตรวจสอบว่าที่อยู่นั้นมีอยู่แล้วในรายการที่เรียงลำดับซึ่งใช้ความซับซ้อน O (logN)

ฉันไม่สามารถมองเห็นวิธีการนี้ใช้เวลาหรือพื้นที่คงที่ทั้งสองจะเพิ่มขึ้นตามขนาดของรายการ

ฉันจะใช้ IdentityHashMap (ระบุว่ายังไม่มี IdentityHashSet) และเก็บแต่ละโหนดลงในแผนที่ ก่อนที่จะจัดเก็บโหนดคุณจะต้องเรียกว่ามีคีย์อยู่ ถ้า Node มีอยู่แล้วคุณจะมีรอบ

ItentityHashMap ใช้ == แทน. equals เพื่อให้คุณตรวจสอบว่าวัตถุอยู่ในหน่วยความจำแทนที่จะเป็นเนื้อหาเดียวกันหรือไม่

ฉันอาจจะช้าและใหม่มากที่จะจัดการกับหัวข้อนี้ แต่ยังคง..

เหตุใดจึงไม่ชี้ที่อยู่ของโหนดและชี้ "ถัดไป" ที่ชี้ไปที่เก็บไว้ในตาราง

หากเราจัดระเบียบด้วยวิธีนี้

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)

ดังนั้นจึงมีวงจรที่เกิดขึ้น

นี่คือรหัสที่รันได้ของฉัน

สิ่งที่ฉันทำคือการเคารพรายการเชื่อมโยงโดยใช้สามโหนดชั่วคราว (ความซับซ้อนของพื้นที่O(1)) ที่ติดตามการเชื่อมโยง

ข้อเท็จจริงที่น่าสนใจเกี่ยวกับการทำคือช่วยตรวจสอบวงจรในรายการที่เชื่อมโยงเพราะเมื่อคุณไปข้างหน้าคุณไม่คาดหวังว่าจะกลับไปที่จุดเริ่มต้น (โหนดรูท) และหนึ่งในโหนดชั่วคราวควรเป็นโมฆะเว้นแต่คุณ มีวงจรซึ่งหมายความว่ามันชี้ไปที่โหนดรูต

ความซับซ้อนเวลาของขั้นตอนวิธีนี้เป็นและความซับซ้อนของพื้นที่O(n)O(1)

นี่คือโหนดคลาสสำหรับรายการที่ลิงก์:

public class LinkedNode{
    public LinkedNode next;
}

นี่คือรหัสหลักที่มีกรณีทดสอบอย่างง่าย ๆ ของสามโหนดที่โหนดสุดท้ายชี้ไปที่โหนดที่สอง:

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

นี่คือกรณีทดสอบอย่างง่าย ๆ ของสามโหนดที่โหนดสุดท้ายชี้ไปที่โหนดที่สอง:

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

รหัสนี้ได้รับการปรับให้เหมาะสมและจะให้ผลลัพธ์ที่รวดเร็วกว่าเมื่อเลือกไว้เป็นคำตอบที่ดีที่สุดรหัสนี้จะช่วยในการไล่ล่าตัวชี้ไปข้างหน้าและข้างหลังซึ่งจะเกิดขึ้นในกรณีต่อไปนี้หากเราทำตาม 'ดีที่สุด คำตอบ 'วิธีการดูผ่านระยะแห้งของสิ่งต่อไปนี้และคุณจะรู้ว่าสิ่งที่ฉันพยายามจะพูดจากนั้นดูปัญหาผ่านวิธีการที่กำหนดด้านล่างและวัดหมายเลข ขั้นตอนเพื่อค้นหาคำตอบ

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

นี่คือรหัส:

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
}

นี่คือทางออกของฉันใน 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;
}

คุณอาจใช้อัลกอริทึมเต่าของฟลอยด์ตามที่แนะนำในคำตอบข้างต้นเช่นกัน

อัลกอริทึมนี้สามารถตรวจสอบว่ารายการที่เชื่อมโยงเดี่ยวมีรอบปิด สิ่งนี้สามารถทำได้โดยการวนซ้ำรายการด้วยสองพอยน์เตอร์ที่จะเคลื่อนที่ด้วยความเร็วที่แตกต่างกัน ด้วยวิธีนี้หากมีรอบสองตัวชี้จะพบในบางจุดในอนาคต

โปรดอย่าลังเลที่จะตรวจสอบการโพสต์บล็อกของฉันในโครงสร้างข้อมูลรายการที่เชื่อมโยงซึ่งฉันได้รวมข้อมูลโค้ดด้วยการใช้อัลกอริทึมดังกล่าวข้างต้นในภาษาจาวา

ความนับถือ,

Andreas (@xnorcode)

นี่คือทางออกสำหรับการตรวจจับรอบ

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 
        }

// ฟังก์ชั่นลิสต์ค้นหารายชื่อที่เชื่อมโยง

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

วิธีนี้มีค่าใช้จ่ายด้านพื้นที่ แต่มีการนำไปใช้ง่ายกว่า:

สามารถระบุ Loop ได้โดยการเก็บโหนดใน Map และก่อนที่จะวางโหนด; ตรวจสอบว่ามีโหนดอยู่แล้ว หากมีโหนดอยู่แล้วในแผนที่นั่นหมายความว่ารายการที่เชื่อมโยงมีการวนซ้ำ

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;

}