연결된 목록에서 루프를 감지하는 방법?

Java로 연결된 목록 구조가 있다고 가정하십시오. 노드로 구성됩니다.

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

각 노드는 다음 노드를 가리키는 마지막 노드를 제외하고 다음 노드를 가리 킵니다. 리스트가 루프를 포함 할 가능성이 있다고하자. 즉, 널 (null) 대신 최종 노드가리스트의 앞에있는 노드 중 하나에 대한 참조를 갖는다.

쓰는 가장 좋은 방법은 무엇입니까

boolean hasLoop(Node first)

true주어진 노드가 루프가있는 목록의 첫 번째 경우 반환 하고 false그렇지 않으면? 일정한 공간과 적당한 시간이 걸리도록 어떻게 쓸 수 있습니까?

다음은 루프가있는 목록의 모습입니다.

Floyd의 사이클 찾기 알고리즘 ( 거북 및 토끼 알고리즘 이라고도 함)을 사용할 수 있습니다 .

아이디어는 목록에 대한 두 개의 참조를 가지고 서로 다른 속도 로 이동하는 것 입니다. 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 's cycle]와 비슷하지만 여기서 느린 노드는 움직이지 않지만 나중에 고정 된 빠른 노드의 위치로 "텔레포트"된다는 점을 제외하고 간격.

설명은 여기에 있습니다 : 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;
}

내가 목록을 일시적으로 변경했을 때 거북이와 토끼에 대한 대안 솔루션은 그리 좋지는 않습니다.

아이디어는 목록을 걷고 가고 갈수록 뒤집는 것입니다. 그런 다음 이미 방문한 노드에 처음 도달하면 다음 포인터가 "뒤로"를 가리키며 반복이 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);
}

거북이와 토끼

Pollard의 rho 알고리즘 살펴보기 . 그것은 똑같은 문제는 아니지만 논리를 이해하고 링크 된 목록에 적용 할 수 있습니다.

(게으 르면 사이클 감지를 확인할 수 있습니다. 확인하십시오. 거북과 토끼에 대한 부분을 확인하십시오.)

여기에는 선형 시간과 2 개의 추가 포인터 만 필요합니다.

자바에서 :

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

(대부분의 솔루션은 null next과 next.nextnull 을 모두 확인하지 않습니다 . 또한 거북이가 항상 뒤에 있기 때문에 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가 됩니다.

따라서 다른 느린 포인터가 head에서 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))을 제안한다고 생각합니다. contains ()에 대한 SortedSet 조회는 log (n)입니다 (javadoc을 확인하십시오.하지만 TreeSet의 기본 구조는 TreeMap이며, 차례로 빨강-검은 나무입니다). 또는 끝까지 루프), n 조회를 수행해야합니다.

클래스를 포함시킬 수 있다면 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의 linkedlist에서 루프를 감지하십시오.

연결된 목록에서 루프를 검색하는 가장 간단한 방법 중 하나를 사용하여 해시 맵을 사용하는 O (N) 복잡성 또는 정렬 기반 방법을 사용하는 O (NlogN)을 수행 할 수 있습니다.

헤드에서 시작하여 목록을 탐색 할 때 정렬 된 주소 목록을 작성하십시오. 새 주소를 삽입 할 때 주소가 정렬 된 목록에 있는지 확인하십시오.이 경우 O (logN) 복잡성이 필요합니다.

고정 시간이나 공간을 차지하는 방법을 볼 수 없으며 목록의 크기에 따라 둘 다 증가합니다.

IdentityHashMap을 사용하고 (아직 IdentityHashSet이없는 경우) 각 노드를 맵에 저장합니다. 노드가 저장되기 전에 containsKey를 호출합니다. 노드가 이미 존재하면주기가 있습니다.

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)링크를 추적 하는 3 개의 임시 노드 (공간 복잡성 )를 사용하여 링크 된 목록을 존중하는 것입니다 .

이 작업에 대한 흥미로운 사실은 연결 목록에서주기를 감지하는 데 도움이되는 것입니다. 앞으로 나아갈 때 시작점 (루트 노드)으로 돌아갈 것으로 예상하지 않고 임시 노드 중 하나가 null이 아닌 경우 루트 노드를 가리키는주기를가집니다.

이 알고리즘의 시간 복잡도는 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));
    }
}

이 코드는 최적의 답변으로 선택된 것보다 더 빠르게 결과를 생성합니다. answer 'method. 다음의 드라이 런을 살펴보면 내가 말하려는 내용을 알 수 있습니다. 그런 다음 아래 주어진 방법을 통해 문제를보고 no를 측정하십시오. 답을 찾기 위해 취한 단계.

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
}

여기 내 자바 솔루션이 있습니다.

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의 거북이 알고리즘을 사용할 수도 있습니다.

이 알고리즘은 단일 연결 목록에 닫힌주기가 있는지 확인할 수 있습니다. 이것은 다른 속도로 이동할 두 개의 포인터로 목록을 반복하여 달성 할 수 있습니다. 이런 식으로 사이클이 있으면 두 포인터가 나중에 어느 시점에서 만날 것입니다.

내 블로그 게시물 을 확인하시기 바랍니다링크 된 목록 데이터 구조에서 . 여기서 위에서 언급 한 알고리즘을 Java 언어로 구현 한 코드 스 니펫도 포함했습니다.

문안 인사,

안드레아스 (@Andreas)

사이클을 감지하는 솔루션은 다음과 같습니다.

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

이 방법은 공간 오버 헤드가 있지만 구현이 더 간단합니다.

루프는 맵에 노드를 저장하여 식별 할 수 있습니다. 그리고 노드를 놓기 전에; 노드가 이미 존재하는지 확인하십시오. 노드가 이미 맵에 존재하면 링크 된 목록에 루프가 있음을 의미합니다.

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;

}