ٻن ڳن Linkedيل فهرستن جو اتحاد ۽ چوڪ  


تڪليف جي سطح وچولو
بار بار پڇڻ ۾ 24 * 7 انوويشن ليبز قبول ڪريو Amazon فلپٽٽ ڪولي ميڊيا Microsoft جي ٽيڪسي 4 پڪ VMware والارٽ ليبز
هاش ڳن -يل فهرست ترتيب ڏيڻ

ٻه ڏنل ڳن listsيل لسٽون، موجوده لسٽن جي عناصر کي اتحاد ۽ اتفاق حاصل ڪرڻ لاءِ هڪ ٻئي ڳن linkedيل لسٽون ٺاهيو.

مثال  

انٽرويو

لسٽ 1: 5 → 9 → 10 → 12 → 14

لسٽ 2: 3 → 5 → 9 → 14 → 21

پيداوار:

چونڪ_ لسٽ: 14 → 9 → 5

يونين_ لسٽ: 21 → 14 → 12 → 10 → 9 → 5 → 3

وضاحت: ڳنيل فهرست نوڊس جو مجموعو آهي. هر نوڊ تسلسل ۾ ڳن isيل آهي. اسان حاصل ڪري سگهون ٿا چونڪ ۽ يونين ڪيترن ئي طريقن سان استعمال ڪندي ٻن ڳن byيل فهرستن جو. پر ، انهي صورت ۾ استعمال ڪرڻ جو ڪارائتو طريقو پهريون آهي ، جڙيل ڳن bothيل لسٽ ٻنهي کي استعمال ڪريو ضم ڪريو ترتيب ۽ پوءِ لڪير سان bothڪيل ٻنهي ڳن listيل لسٽن کي گڏيل ۽ گڏيل ڳن listsيل لسٽن لاءِ حاصل ڪريو. هتي ، ضم ٿيل قسم اڪثر ڳن algorithيل فهرست جي ترتيب لاءِ ترجيح ڏني ويندي آهي ٻين الگورتھمز کان جيڪي خراب ڪم ڪن ٿا.

الورورٿم  

  1. لسٽ جي سربراهي ۽ اڳيان واري پوائنٽر کي ظاهر ڪري هڪ ڳن listيل فهرست ٺاهيو.
  2. داخل ڪريو فنڪ استعمال ڪندي لسٽ ۾ ٻنهي عناصر شامل ڪريو.
  3. ضم ٿيل ترتيب واري الگورتھم کي استعمال ڪندي ٻنهي ڳن listsيل فهرستن کي ترتيب ڏيو.
  4. آخرڪار ، لسٽ واري فهرست جي ترتيب ۽ ترتيب جي حاصل ڪرڻ لاءِ ترتيب وار فهرست ٻنهي لڪير سان اسڪين ڪيو.

وضاحت  

پهريون ، اسان پنهنجي پروگرام ۾ نوڊ ڪلاس ٺاهي هڪ نوڊ ٺاهيون ٿا ، انهي ڪري جو اسان پنهنجي ڳن Linkedيل لسٽ ٺاهي سگهون ٿا. اسان جي پروگرام ۾ ، اسان ٻه ترتيب واري ڳن linkedيل فهرست ٺاهي ٿا. ان کان پوءِ ، اسان ترتيب ڏياريندڙ الگورتھم کي استعمال ڪندي ٻنهي ڳن listيل فهرست ترتيب ڏيون ٿا ۽ پوءِ اسان پنهنجن ڳن linkedيل فهرستن جو اتحاد ۽ تعلقي حاصل ڪرڻ لاءِ پنهنجو ڪم ٺاهيو. ٻنهي ڳن listsيل فهرستن کي ترتيب ڏيڻ کانپوءِ انهن کي لڪيرين سان اسڪين ڪرڻ آسان آهي ته جيئن اسان پنهنجي ڳن listsيل فهرستن جو اتحاد ۽ گڏيل حاصل ڪري سگهون.

پڻ ڏسو
هيڊ پوائنٽر کان بغير ڳن listيل لسٽ مان هڪ نوڊ ختم ڪريو

مثال طور ، ٻن ڳن listsيل لسٽون ٺاهيو 'list1' ۽ 'list2' ، ۽ انهن ٻنهي ۾ عنصر داخل ڪريو اسان جي Node ڪلاس جاوا يا نوڊ ۾ سي ++ ۾ جوڙجڪ. ان کان پوءِ ، اسان پنهنجي ڳن linkedيل لسٽس لسٽ 1 ۽ يونين 2 جي ايسوسيئيشن کي استعمال ڪريون ٿا جيڪو اسان ٺاهيو آهي “get_union” جنهن ۾ اسين انهي سان ڳن argumentيل ٻنهي لنڪ واري لسٽ جو سربراهه بڻون ٿا ۽ اسان يونين کي بچائڻ لاءِ هڪ عارضي لسٽ ٺاهي ان جي ٻنهي فهرستن ۾ عنصر مدد سان جڏهن ته لوپ پهريون جڏهن لوپ ٽم ۾ پهرين لسٽ جو عنصر شامل ڪرڻ لاءِ. عارضي طور لسٽ 2 عناصر کي داخل ڪرڻ لاءِ لسٽ ۽ سيڪنڊ. لسٽ ۾ جيڪڏهن اهي اڳ ۾ ئي شامل نه آهن ۽ آخرڪار اسان جي فهرست عناصر سان ڀريل آهي جيڪي ٻنهي جڙيل فهرست ۾ عام آهن. ان کان پوءِ ، اسان ٻنهي ڳن listsيل فهرستن جي چوڏهين کي ڳولڻ لاءِ پنهنجو ‘حاصل ڪيو چڪاس’ جو طريقو ڪتب آڻينداسين ، جنهن ۾ اسين ٻيهر ڳن listيل ٻنهي فهرستن جا سر کڻندا آهيون ۽ ٻيهر استعمال ڪنداسين جڏهن ته لوپ انهي ۾ ڳن linkedيل فهرست جو هڪ عنصر شامل ڪرڻ صرف ان صورت ۾ جڏهن اهي ڳن linkedيل فهرست ٻنهي ۾ عام آهن.

تي عملدرآمد  

C ++ پروگرام لاءِ جوڙيل ۽ ٻن ڳن Linkedيل فهرستن جي چوٽي

#include<iostream>
#include<stdlib.h>
using namespace std;

struct Node
{
    int value;
    struct Node* next;
};

void insert(struct Node** head, int new_value)
{
    struct Node* NewNode = (struct Node*) malloc(sizeof(struct Node));

    NewNode->value = new_value;

    NewNode->next = (*head);

    (*head) = NewNode;
}

void Front_Back(struct Node* source, struct Node** front, struct Node** back)
{
    struct Node* fast;
    struct Node* slow;
    if (source==NULL || source->next==NULL)
    {
        *front = source;
        *back = NULL;
    }
    else
    {
        slow = source;
        fast = source->next;

        while (fast != NULL)
        {
            fast = fast->next;
            if (fast != NULL)
            {
                slow = slow->next;
                fast = fast->next;
            }
        }

        *front = source;
        *back = slow->next;
        slow->next = NULL;
    }
}

struct Node* Sort_merge(struct Node* fst, struct Node* sec)
{
    struct Node* result = NULL;

    if (fst == NULL)
        return(sec);
    else if (sec==NULL)
        return(fst);

    if (fst->value <= sec->value)
    {
        result = fst;
        result->next = Sort_merge(fst->next, sec);
    }
    else
    {
        result = sec;
        result->next = Sort_merge(fst, sec->next);
    }
    return(result);
}

void Sort(struct Node** head)
{
    struct Node *head_node= *head;
    struct Node *a, *b;

    if ((head_node == NULL) || (head_node->next == NULL))
        return;

    Front_Back(head_node, &a, &b);

    Sort(&a);
    Sort(&b);

    *head = Sort_merge(a, b);
}

struct Node *get_Union(struct Node *head1, struct Node *head2)
{
    struct Node *result = NULL;
    struct Node *t1 = head1, *t2 = head2;

    while (t1 != NULL && t2 != NULL)
    {
        if (t1->value < t2->value)
        {
            insert(&result, t1->value);
            t1 = t1->next;
        }

        else if (t1->value>t2->value)
        {
            insert(&result, t2->value);
            t2 = t2->next;
        }
        else
        {
            insert(&result, t2->value);
            t1 = t1->next;
            t2 = t2->next;
        }
    }

    while (t1 != NULL)
    {
        insert(&result, t1->value);
        t1 = t1->next;
    }
    while (t2 != NULL)
    {
        insert(&result, t2->value);
        t2 = t2->next;
    }

    return result;
}

struct Node *get_Intersection(struct Node *head1, struct Node *head2)
{
    struct Node *result = NULL;
    struct Node *t1 = head1, *t2 = head2;

    while (t1 != NULL && t2 != NULL)
    {
        if (t1->value < t2->value)
            t1 = t1->next;

        else if (t1->value > t2->value)
            t2 = t2->next;

        else
        {
            insert(&result, t2->value);

            t1 = t1->next;
            t2 = t2->next;
        }
    }

    return result;
}

void printList (struct Node *node)
{
    while (node != NULL)
    {
        cout<<node->value << " ";
        node = node->next;
    }
    cout<<endl;
}

int main()
{
    struct Node* head1 = NULL;
    struct Node* head2 = NULL;
    struct Node* intersection_list = NULL;
    struct Node* union_list = NULL;

    insert(&head1, 20);
    insert(&head1, 4);
    insert(&head1, 15);
    insert(&head1, 10);
    insert(&head1, 11);

    insert(&head2, 10);
    insert(&head2, 2);
    insert(&head2, 4);
    insert(&head2, 8);

    Sort(&head1);
    Sort(&head2);

    intersection_list = get_Intersection(head1, head2);
    union_list = get_Union(head1, head2);

    cout<<"First list is \n";
    printList(head1);

    cout<<"\nSecond list is \n";
    printList(head2);

    cout<<"\nIntersection list is \n";
    printList(intersection_list);

    cout<<"\nUnion list is \n";
    printList(union_list);

    return 0;
}
First list is
4 10 11 15 20

Second list is
2 4 8 10

Intersection list is
10 4

Union list is
20 15 11 10 8 4 2

جاوا پروگرام يونين ۽ چورائين جي ٻن ڳن Linkedيل فهرستن جو

class Solution1
{
    Node head;


    class Node
    {
        int data;
        Node next;
        Node(int d)
        {
            data = d;
            next = null;
        }
    }


    void get_union(Node hd1, Node hd2)
    {
        Node t1 = hd1, t2 = hd2;


        while (t1 != null)
        {
            insert(t1.data);
            t1 = t1.next;
        }


        while (t2 != null)
        {
            if (!is_Present(head, t2.data))
                insert(t2.data);
            t2 = t2.next;
        }
    }

    void get_intrSection(Node hd1, Node hd2)
    {
        Node rst = null;
        Node t1 = hd1;


        while (t1 != null)
        {
            if (is_Present(hd2, t1.data))
                insert(t1.data);
            t1 = t1.next;
        }
    }


    void printList()
    {
        Node temp = head;
        while (temp != null)
        {
            System.out.print(temp.data + " ");
            temp = temp.next;
        }
        System.out.println();
    }


    void insert(int new_data)
    {

        Node new_node = new Node(new_data);


        new_node.next = head;


        head = new_node;
    }


    boolean is_Present(Node head, int data)
    {
        Node t = head;
        while (t != null)
        {
            if (t.data == data)
                return true;
            t = t.next;
        }
        return false;
    }


    public static void main(String args[])
    {
        Solution1 llist1 = new Solution1();
        Solution1 llist2 = new Solution1();
        Solution1 unin = new Solution1();
        Solution1 intersecn = new Solution1();


        llist1.insert(20);
        llist1.insert(4);
        llist1.insert(15);
        llist1.insert(10);


        llist2.insert(10);
        llist2.insert(2);
        llist2.insert(4);
        llist2.insert(8);

        intersecn.get_intrSection(llist1.head, llist2.head);
        unin.get_union(llist1.head, llist2.head);

        System.out.println("First List is");
        llist1.printList();

        System.out.println("Second List is");
        llist2.printList();

        System.out.println("Intersection List is");
        intersecn.printList();

        System.out.println("Union List is");
        unin.printList();
    }
}
First List is
10 15 4 20
Second List is
8 4 2 10
Intersection List is
4 10
Union List is
2 8 20 4 15 10

ٻن ڳن Linkedيل فهرستن جي يونين ۽ چوراہے جي پيچيدگي جو تجزيو  

وقت جي پيچيدگي

 اي (ايم + اين) جتي "م" ۽ “ن” پهرين ۽ ٻي لسٽ ۾ ترتيب ڏنل عناصر جو تعداد ترتيب ڏنو ويو آهي.

پڻ ڏسو
ڏنل ڳن listيل لسٽ جي آخر کان نيون نوڊ ختم ڪريو

خلائي پيچيدگي

 اي (ايم + اين) جتي "م" ۽ “ن” پهرين ۽ ٻي لسٽ ۾ ترتيب ڏنل عناصر جو تعداد ترتيب ڏنو ويو آهي.