የሁለት የተገናኙ ዝርዝሮች ህብረት እና መገናኛ  


የችግር ደረጃ መካከለኛ
ውስጥ በተደጋጋሚ ተጠየቀ 24 * 7 የፈጠራ ላብራቶሪዎች የተከማቸ አማዞን Flipkart ኮምሊ ሚዲያ የ Microsoft ታክሲ 4 ዋስትና VMware የዎልማርት ላብራቶሪዎች
ሃሽ የተገናኘ-ዝርዝር መደርደር

ሁለት ተሰጥቷል የተገናኙ ዝርዝሮች, የነባር ዝርዝሮች አካላት አንድነት እና መገናኛውን ለማግኘት ሌላ ሁለት የተገናኙ ዝርዝሮችን ይፍጠሩ።

ለምሳሌ  

ግቤት

ዝርዝር 1: 5 → 9 → 10 → 12 → 14

ዝርዝር 2: 3 → 5 → 9 → 14 → 21

ውጤት

የመተላለፊያ_ ዝርዝር: 14 → 9 → 5

የኅብረት_ ዝርዝር: 21 → 14 → 12 → 10 → 9 → 5 → 3

ማብራሪያ: የተገናኘ ዝርዝር የአንጓዎች ስብስብ ነው። እያንዳንዱ መስቀለኛ መንገድ በቅደም ተከተል ተያይ connectedል። እኛ ማግኘት እንችላለን መስቀለኛ መንገድ ማህበር በርካታ ዘዴዎችን በመጠቀም ሁለት የተያያዙ ዝርዝሮች። ግን ፣ በዚህ ጉዳይ ላይ ለመጠቀም ቀልጣፋው ዘዴ መጀመሪያ ነው ፣ ሁለቱንም የተገናኘውን ዝርዝር በመጠቀም መደርደር ማዋሃድ እና ከዚያ የሁለቱም የተገናኙ ዝርዝሮች መሻገሪያ እና አንድነት ለማግኘት ሁለቱን የተደረደሩ የተገናኙ ዝርዝርን በመስመር ላይ ያረጋግጡ ፡፡ እዚህ የውህደት አይነት ብዙውን ጊዜ ደካማ ከሚያደርጉት ሌሎች ስልተ ቀመሮች ይልቅ የተገናኘውን ዝርዝር ለመደርደር ይመረጣል ፡፡

አልጎሪዝም  

  1. የዝርዝሩን ዋና እና ቀጣይ ጠቋሚ በማወጅ የተገናኘ ዝርዝር ይፍጠሩ።
  2. አስገባ ፈንሾችን በመጠቀም በሁለቱም ዝርዝር ውስጥ ያሉትን አካላት ያስገቡ ፡፡
  3. የማዋሃድ ድርድር ስልተ ቀመሩን በመጠቀም ሁለቱንም የተገናኙ ዝርዝሮችን ደርድር።
  4. በመጨረሻም ፣ የዝርዝሩን ህብረት እና መስቀለኛ መንገድ ለማግኘት በሁለቱም የተደረደሩ ዝርዝርን በቅደም ተከተል ይቃኙ ፡፡

ማስረጃ  

በመጀመሪያ ፣ የእኛን የተገናኘ ዝርዝር ለመፍጠር እንድንችል በፕሮግራማችን ውስጥ የመስቀለኛ ክፍልን በመፍጠር መስቀለኛ መንገድ እንፈጥራለን ፡፡ በፕሮግራማችን ውስጥ ሁለት ያልተጣራ የተገናኘ ዝርዝር እንፈጥራለን ፡፡ ከዚያ በኋላ የተገናኘውን ዝርዝር የእኛን የመለየት ስልተ-ቀመር በመጠቀም እንለያቸዋለን እና ከዚያ የተገናኘን ዝርዝሮቻችንን አንድነት እና መገናኛውን ለማግኘት ተግባራችንን እንፈጥራለን ፡፡ ሁለቱንም የተገናኙትን ዝርዝሮች ከለዩ በኋላ የተገናኘን ዝርዝሮቻችንን አንድነት እና ማቋረጫ ማግኘት እንድንችል በመስመር ላይ ለመቃኘት ቀላል ነው ፡፡

ተመልከት
የጭንቅላት ጠቋሚ ያለ ኖድ ከተገናኘው ዝርዝር ይሰርዙ

ለምሳሌ ፣ ሁለት የተገናኙ ዝርዝሮችን ‹list1› እና ‹list2› ይፍጠሩ እና በሁለቱም ውስጥ አባሎችን በጃቫ ወይም ኖድ በእኛ የመስቀለኛ ክፍል ያስገቡ ፡፡ መዋቅር በ c ++ ውስጥ. ከዚያ በኋላ የሁለቱን የተገናኘ ዝርዝርን ጭንቅላት በውስጡ እንደ ክርክር የምንወስድበት ‹get_union› ያደረግነውን ተግባር በመጠቀም የሁለታችንም የተገናኙ ዝርዝሮች ዝርዝር 1 እና ዝርዝር 2 ህብረት እናገኛለን እናም ህብረቱን ለማዳን ጊዜያዊ ዝርዝር እንፈጥራለን ፡፡ በሁለቱም ዝርዝሮች ውስጥ ያለው ንጥረ ነገር በ እገዛ ዘንበል እያለ የመጀመሪያውን ዝርዝር በሙከራ ጊዜ ለማስገባት ሉፕ እያለ ዝርዝሩን በ 2 ቴምፕ ውስጥ ለማስገባት ዝርዝር እና ሁለተኛው ፡፡ እነሱ በዝርዝሩ ውስጥ ከሌሉ ይዘርዝሩ እና በመጨረሻም በሁለቱም በተገናኘው ዝርዝር ውስጥ በተለመዱ ንጥረ ነገሮች የተሞላ ዝርዝር አግኝተናል ፡፡ ከዚያ በኋላ የሁለቱን የተገናኙ ዝርዝሮች መገናኛውን ለማግኘት የእኛን ‹ያግኙን መገንጠያ› ዘዴችንን እንጠቀማለን ፣ በዚህ ውስጥ እንደገና የሁለቱን የተገናኘ ዝርዝር ጭንቅላት የምንወስድበት እና እንደገና የምንጠቀምበት ዘንበል እያለ በሁለቱም የተገናኙ ዝርዝር ውስጥ የተለመዱ ከሆኑ ብቻ የሁለቱም የተገናኘ ዝርዝር አንድ አካል ለማስገባት ፡፡

አፈጻጸም  

የ C ++ ፕሮግራም ለህብረት እና ሁለት የተገናኙ ዝርዝሮች መገንጠያ

#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

የጃቫ ፕሮግራም ለህብረት እና ሁለት የተገናኙ ዝርዝሮች መገንጠያ

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

የአንድነት ውስብስብ ትንተና እና የሁለት የተገናኙ ዝርዝሮች መገንጠያ  

የጊዜ ውስብስብነት

 ኦ (m + n) የት "M"“N” በቅደም ተከተል በአንደኛ እና በሁለተኛ ዝርዝሮች ውስጥ የሚገኙት ንጥረ ነገሮች ብዛት ናቸው ፡፡

ተመልከት
ከተጠቀሰው ዝርዝር መጨረሻ Nth node ን ይሰርዙ

የቦታ ውስብስብነት

 ኦ (m + n) የት "M"“N” በቅደም ተከተል በአንደኛ እና በሁለተኛ ዝርዝሮች ውስጥ የሚገኙት ንጥረ ነገሮች ብዛት ናቸው ፡፡