ציילן פּערז פון צוויי לינגקט רשימות וועמענס סומע איז גלייַך צו אַ געגעבן ווערט


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

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

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

בייַשפּיל

LinkedList1 = 11 à 6 à 1 à 8

LinkedList2 = 5 à 3 à 1 à 9

Sum = 9
2

דערקלערונג: עס זענען צוויי פּערז הייסט, 6, 3, און 8, 1 וואָס סאַמז די ווערט צו די געגעבן ווערט 9.

 

אַלגערידאַם צו ציילן פּערז פון לינגקט רשימות וועמענס סומע איז גלייַך צו אַ געגעבן ווערט

1. Push all the integer values to the two different linked lists.
2. Declare a set.
3. Set the count to 0.
4. Iterate over the first linked list and put all the values of it into the linked list1.
5. Iterate over the second linked list
    1. Check if the set contains the difference between the value of x and a current element of linked list2.
        1. If true then increase the value of count by 1.
6. Return count.

דערקלערונג

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

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

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

ציילן פּערז פון צוויי לינגקט רשימות וועמענס סומע איז גלייַך צו אַ געגעבן ווערט

קאָדעקס

C ++ צו ציילן פּערז פון צוויי לינגקט רשימות, וועמענס סומע איז גלייַך צו אַ געגעבן ווערט

#include<iostream>
#include<unordered_set>

using namespace std;

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

void implementLinkedList(struct Node** headReference, int newItem)
{
    struct Node* newNode =	(struct Node*) malloc(sizeof(struct Node));

    newNode->data = newItem;

    newNode->next = (*headReference);

    (*headReference) = newNode;
}
int getPairOfsum (struct Node* head1, struct Node* head2,int sum)
{
    int count = 0;

    unordered_set<int> SET;

    while (head1 != NULL)
    {
        SET.insert(head1->data);

        head1 = head1->next;
    }

    while (head2 != NULL)
    {
        if (SET.find(sum - head2->data) != SET.end())
            count++;

        head2 = head2->next;
    }
    return count;
}
int main()
{
    struct Node* head1 = NULL;
    struct Node* head2 = NULL;

    implementLinkedList (&head1,11);
    implementLinkedList (&head1, 6);
    implementLinkedList (&head1, 1);
    implementLinkedList (&head1, 8);

    implementLinkedList (&head2, 5);
    implementLinkedList (&head2, 3);
    implementLinkedList (&head2, 1);
    implementLinkedList (&head2, 9);

    int sum = 9;

    cout << "Count = "<< getPairOfsum (head1, head2, sum);
    return 0;
}
Count = 2

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

import java.util.Arrays;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedList;

class PairOfSumInLinkedList1
{
    public static int getPairOfsum(LinkedList<Integer> head1, LinkedList<Integer> head2, int sum)
    {
        int count = 0;

        HashSet<Integer> SET = new HashSet<Integer>();

        Iterator<Integer> itr1 = head1.iterator();
        while (itr1.hasNext())
        {
            SET.add(itr1.next());

        }

        Iterator<Integer> itr2 = head2.iterator();
        while (itr2.hasNext())
        {
            if (!(SET.add(sum - itr2.next())))
                count++;

        }
        return count;
    }
    public static void main(String[] args)
    {
        Integer arr1[] = {11, 6, 1, 8};
        Integer arr2[] = {5, 3, 1, 9};

        LinkedList<Integer> head1 = new LinkedList<>(Arrays.asList(arr1));

        LinkedList<Integer> head2 = new LinkedList<>(Arrays.asList(arr2));

        int x = 9;

        System.out.println("Count = " + getPairOfsum(head1, head2, x));
    }
}
Count = 2

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

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

אָ (n1 + n2) ווו “N1” און “N2” זענען די נומערן פון עלעמענטן אין די לינגקט רשימה. מיר קענען דערגרייכן לינעאַר צייט קאַמפּלעקסיטי. ווייַל מיר האָבן דורכגעקאָכט ביידע די לינגקט רשימות און געוויינט האַשסעט.

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

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