לינקעד רשימה ציקל  


שוועריקייט לעוועל גרינג
אָפט געבעטן אין אַקקאָליטע אַמאַזאָן מאַק סאַמסונג
לינקעד-רשימה צוויי טייַטל

פּראָבלעם סטאַטעמענט  

די "לינקעד רשימה ציקל" פּראָבלעם שטאַטן אַז איר באַקומען אַ לינגקט רשימה. געפינען אויב עס כּולל קיין שלייף אָדער נישט?

לינקעד רשימה ציקלשפּילקע

 לינגקט רשימה מיט ציקל

בייַשפּיל  

1->2->3
No Loop

דערקלערונג: די לינגקט רשימה קען נישט אַנטהאַלטן קיין שלייף ווייַל אויב עס איז געווען, עס וואָלט האָבן שוין צוויי קיין דעס פּוינטינג צו דער זעלביקער נאָדע. אָדער עס וואָלט נישט געווען קיין נאָדע מיט Null ווי זיין ווייַטער נאָדע.

1->2->3->4
   ^     |
   |_____|
Yes there exists a loop

דערקלערונג: יא עס איז אַ שלייף ווייַל נאָדע מיט ווערט 1 און נאָדע מיט ווערט 4 איז פּוינטינג צו דער זעלביקער נאָדע 2.

ניצן האַשינג מעטאַד  

אַלגאָריטהם

1. Initialize a hash table of type Node.
2. Start traversing the list. While node of the list is not null check if the current value is already stored in the hash table, if yes return true.
3. Else store it in the hash table and increment the pointer of the hash table.
4. Return false.

מיר נוצן דאָ אַ האַש טיש אָדער האַשסעט צו געפֿינען אויב עס איז אַ שלייף אין די לינגקט רשימה. דער זעלביקער טעכניק איז געניצט ווען מיר דאַרפֿן צו געפֿינען אויב אונדזער מענגע כּולל דופּליקאַטן. מיר נוצן HashSet צו קראָם די ווערט וואָס מיר וועלן זאָל ניט זיין ריפּיטיד. ווייַל אַ HashSet אַלאַוז נאָר איין סטאָרידזש פון קיין עלעמענט (ד"ה עס קען נישט קראָם דופּליקאַטן). די פאַנגקשאַנאַליטי איז פּאַסיק פֿאַר אונדזער נוצן. אזוי מיר נוצן אַ האַשסעט צו קאָנטראָלירן ביי די לינגקט רשימה אויב מיר געפֿינען די זעלבע נאָדע צוויי מאָל. מיר וויסן אַז עס איז אַ שלייף אין די לינגקט רשימה. אויב מיר קענען פאָרן די לינגקט רשימה אָן צוויי מאָל די זעלבע נאָדע. מיר וויסן אַז קיינער פון די עלעמענטן איז ריפּיטיד און עס איז קיין שלייף אין די לינגקט רשימה.

זע אויך
פאַרקערט אַ לינגקט רשימה

קאָדעקס

C ++ פּראָגראַם צו געפֿינען לינק רשימה ציקל

#include <bits/stdc++.h> 
using namespace std; 
  
struct Node{ 
    int data; 
    struct Node* next; 
}; 
  
void push(struct Node** head_ref, int new_data){ 
    struct Node* new_node = new Node; 
  
    new_node->data = new_data; 
  
    new_node->next = (*head_ref); 
  
    (*head_ref) = new_node; 
} 
  
bool detectCycle(struct Node* h){ 
    unordered_set<Node*> s; 
    while (h != NULL) { 
        if (s.find(h) != s.end()) 
            return true; 
  
        s.insert(h); 
  
        h = h->next; 
    } 
  
    return false; 
} 
  
int main(){ 
    struct Node* head = NULL; 
  
    push(&head, 20); 
    push(&head, 4); 
    push(&head, 15); 
    push(&head, 10); 
  
    head->next->next->next->next = head; 
  
    if(detectCycle(head)) 
        cout << "Loop found"; 
    else
        cout << "No Loop"; 
  
    return 0; 
}
Loop found

Java פּראָגראַם צו געפֿינען די לינק רשימה ציקל

import java.util.*;
  
class Cycle{ 
  
    static Node head;
    static class Node { 
        int data; 
        Node next; 
        Node(int d) 
        { 
            data = d; 
            next = null; 
        } 
    } 
  
    static public void push(int new_data){ 
        Node new_node = new Node(new_data); 
  
        new_node.next = head; 
  
        head = new_node; 
    } 
  
    static boolean detectCycle(Node h){ 
        HashSet<Node> s = new HashSet<Node>(); 
        while(h != null){ 
            if(s.contains(h)) 
                return true; 
  
            s.add(h); 
  
            h = h.next; 
        } 
  
        return false; 
    } 
  
    public static void main(String[] args){ 
        Cycle list = new Cycle(); 
  
        list.push(20); 
        list.push(4); 
        list.push(15); 
        list.push(10); 
  
        list.head.next.next.next.next = list.head; 
  
        if(detectCycle(head)) 
            System.out.println("Loop found"); 
        else
            System.out.println("No Loop"); 
    } 
}
Loop found

קאַמפּלעקסיטי אַנאַליסיס

צייט קאַמפּלעקסיטי

אָ (N) וווּ n איז די נומער פון ינסערטאַד נאָודז אין די געגעבן רשימה. זינט מיר האָבן געוויינט האַשסעט אָדער ונאָרדערעד_סעט וואָס ינשורז ינסערשאַן און זוכן אין אָ (1) וואָס ערלויבט אונדז צו דערגרייכן לינעאַר צייט קאַמפּלעקסיטי.

ספעיס קאַמפּלעקסיטי

אָ (N) ווייַל מיר געוויינט אַ האַשסעט אין וואָס די ערגסט פאַל מיר האָבן צו שטעלן N נאָודז.

פלויד ס ציקל-דערגייונג אַלגערידאַם  

טריט

  1. ניצן צוויי פּוינטערז פּאַמעלעך און געשווינד.
  2. מאַך פּאַמעלעך טייַטל דורך 1 נאָדע און פאַסטן ביי 2 אין יעדער שריט.
  3. אויב ביידע פּוינטערז טרעפן אין קיין פונט, די ציקל איז פאָרשטעלן.
זע אויך
רעזערוווואַר מוסטערונג

אַלגאָריטהם

1. Initialize two pointers fast and slow as head of the list.
2. Traverse while fast or slow is not null. Increment slow by 1 node and fast by 2 nodes.
3. Check at each traversal if slow equals to fast, print "Loop found" and return 1.
4. Else return 0 and print "No loop".

קאָדעקס

C ++ פּראָגראַם צו געפֿינען לינק רשימה ציקל

#include <bits/stdc++.h> 
using namespace std; 
  
class Node{ 
public: 
    int data; 
    Node* next; 
}; 
  
void push(Node** head_ref, int new_data){ 
    Node* new_node = new Node(); 
  
    new_node->data = new_data; 
  
    new_node->next = (*head_ref); 
  
    (*head_ref) = new_node; 
} 
  
int detectCycle(Node* list){ 
    Node *slow = list, *fast = list; 
  
    while (slow && fast && fast->next) { 
        slow = slow->next; 
        fast = fast->next->next; 
        if (slow == fast) { 
            cout << "Found Loop"; 
            return 1; 
        } 
    } 
    return 0; 
} 
  
int main(){ 
    Node* head = NULL; 
  
    push(&head, 20); 
    push(&head, 4); 
    push(&head, 15); 
    push(&head, 10); 
  
    head->next->next->next->next = head; 
    if(!detectCycle(head))
        cout<<"No Loop"; 
  
    return 0; 
} 
Loop found

Java פּראָגראַם צו געפֿינען די לינק רשימה ציקל

class Cycle{ 
  
    Node head; 
  
    class Node { 
        int data; 
        Node next; 
        Node(int d) 
        { 
            data = d; 
            next = null; 
        } 
    } 
  
    public void push(int new_data){ 
        Node new_node = new Node(new_data); 
  
        new_node.next = head; 
  
        head = new_node; 
    } 
  
    int detectCycle(){ 
        Node slow = head, fast = head; 
        while (slow != null && fast != null && fast.next != null) { 
            slow = slow.next; 
            fast = fast.next.next; 
            if (slow == fast) { 
                System.out.println("Found loop"); 
                return 1; 
            } 
        } 
        return 0; 
    } 
  
    public static void main(String args[]){ 
        Cycle list = new Cycle(); 
  
        list.push(20); 
        list.push(4); 
        list.push(15); 
        list.push(10); 
  
        list.head.next.next.next.next = list.head; 
  
        if(list.detectCycle()==0)
             System.out.println("No loop");  
    }  
}
Loop found

קאַמפּלעקסיטי אַנאַליסיס

צייט קאַמפּלעקסיטי

אָ (N) וווּ N איז די נומער פון ינסערטאַד נאָודז אין די געגעבן רשימה.

ספעיס קאַמפּלעקסיטי

אָ (1) ווייַל מיר געוויינט קעסיידערדיק עקסטרע פּלאַץ. דאָ מיר האָבן נישט סטאָרד קיין עקסטרע אינפֿאָרמאַציע וועגן יעדער פון די נאָודז. אזוי מיר האָבן קעסיידערדיק פּלאַץ קאַמפּלעקסיטי.

מאַרקינג באזוכט נאָודז אָן מאַדאַפייינג די לינגקט רשימה דאַטן סטרוקטור  

אַלגערידאַם צו דעטעקט לינגקט רשימה ציקל

1. Initialize an extra node.
2. Traverse through the list while the head is not null. If head->next is null i.e. there is no cycle, return false.
3. Else if head->next is equal to the extra node, return true.
4. Create a node to store the pointer of the next node.
5. Store extra node in a pointer to the next node.
6. Update the head to the next node.
7. Return false.

דאָ מיר באשאפן אַ צייַטווייַליק נאָדע, מיר ווייַזן אַלע די נאָודז צו דעם נייַ נאָדע. אַזוי, אויב אין אַ צייט מיר קומען אַריבער אַ נאָדע וואָס שוין ווייזט די צייַטווייַליק נאָדע. דערנאָך מיר וויסן אַז עס איז אַ שלייף אַנדערש די לינגקט רשימה כּולל נישט אַ ציקל.

זע אויך
פליסנדיק סומע פון ​​1 ד עריי לעעטקאָדע לייזונג

קאָדעקס

C ++ פּראָגראַם צו געפֿינען לינק רשימה ציקל

#include <iostream> 
using namespace std; 
  
struct Node{ 
    int key; 
    struct Node* next; 
}; 
  
Node* newNode(int key){ 
    Node* temp = new Node; 
    temp->key = key; 
    temp->next = NULL; 
    return temp; 
} 
  
bool detectCycle(Node* head){ 
  
    Node* temp = new Node; 
    while (head != NULL) { 
  
        if(head->next == NULL){ 
            return false; 
        } 
  
        if(head->next == temp){ 
            return true; 
        } 
  
        Node* nex = head->next; 
  
        head->next = temp; 
  
        head = nex; 
    } 
  
    return false; 
} 
  
int main(){ 
    Node* head = newNode(1); 
    head->next = newNode(2); 
    head->next->next = newNode(3); 
    head->next->next->next = newNode(4); 
    head->next->next->next->next = newNode(5); 
  
    head->next->next->next->next->next = head->next->next; 
  
    bool found = detectCycle(head); 
    if(found) 
        cout << "Loop Found"; 
    else
        cout << "No Loop"; 
  
    return 0; 
}
Loop found

Java פּראָגראַם צו געפֿינען די לינק רשימה ציקל

class Cycle{ 
  
    static class Node { 
        int key; 
        Node next; 
    }; 
  
    static Node newNode(int key){ 
        Node temp = new Node(); 
        temp.key = key; 
        temp.next = null; 
        return temp; 
    } 
  
    static void printList(Node head){ 
        while (head != null) { 
            System.out.print(head.key + " "); 
            head = head.next; 
        } 
        System.out.println(); 
    } 
  
    static boolean detectCycle(Node head){ 
  
        Node temp = new Node(); 
        while (head != null) { 
  
            if(head.next == null){ 
                return false; 
            } 
  
            if (head.next == temp) { 
                return true; 
            } 
  
            Node nex = head.next; 
  
            head.next = temp; 
  
            head = nex; 
        } 
  
        return false; 
    } 
  
    public static void main(String args[]){ 
        
        Node head = newNode(1); 
        head.next = newNode(2); 
        head.next.next = newNode(3); 
        head.next.next.next = newNode(4); 
        head.next.next.next.next = newNode(5); 
  
        head.next.next.next.next.next = head.next.next; 
  
        boolean found = detectCycle(head); 
        if (found) 
            System.out.println("Loop Found"); 
        else
            System.out.println("No Loop"); 
    } 
}
Loop found

קאַמפּלעקסיטי אַנאַליסיס

צייט קאַמפּלעקסיטי

אָ (N) וווּ N איז די נומער פון ינסערטאַד נאָודז אין די געגעבן רשימה.

ספעיס קאַמפּלעקסיטי

אָ (1) ווייַל מיר געוויינט קעסיידערדיק עקסטרע פּלאַץ. דאָ מיר האָבן באשאפן נאָר אַ איין נייַ נאָדע צו וואָס אַלע אנדערע נאָודז ווייַזן.