Open in App
Not now

# Count pairs from two linked lists whose sum is equal to a given value

• Difficulty Level : Easy
• Last Updated : 13 Jan, 2023

Given two linked lists(can be sorted or unsorted) of size n1 and n2 of distinct elements. Given a value x. The problem is to count all pairs from both lists whose sum is equal to the given value x.

Note: The pair has an element from each linked list.

Examples:

```Input : list1 = 3->1->5->7
list2 = 8->2->5->3
x = 10
Output : 2
The pairs are:
(5, 5) and (7, 3)

Input : list1 = 4->3->5->7->11->2->1
list2 = 2->3->4->5->6->8-12
x = 9
Output : 5```

Method 1 (Naive Approach): Using two loops pick elements from both the linked lists and check whether the sum of the pair is equal to x or not.

Implementation:

## C++

 `// C++ implementation to count pairs from both linked ` `// lists  whose sum is equal to a given value` `#include ` `using` `namespace` `std;`   `/* A Linked list node */` `struct` `Node` `{` `  ``int` `data;` `  ``struct` `Node* next;` `};`   `// function to insert a node at the` `// beginning of the linked list` `void` `push(``struct` `Node** head_ref, ``int` `new_data)` `{` `  ``/* allocate node */` `  ``struct` `Node* new_node =` `          ``(``struct` `Node*) ``malloc``(``sizeof``(``struct` `Node));` ` `  `  ``/* put in the data  */` `  ``new_node->data  = new_data;` ` `  `  ``/* link the old list to the new node */` `  ``new_node->next = (*head_ref);` ` `  `  ``/* move the head to point to the new node */` `  ``(*head_ref)    = new_node;` `}`   `// function to count all pairs from both the linked lists` `// whose sum is equal to a given value` `int` `countPairs(``struct` `Node* head1, ``struct` `Node* head2, ``int` `x)` `{` `    ``int` `count = 0;` `    `  `    ``struct` `Node *p1, *p2;` `    `  `    ``// traverse the 1st linked list` `    ``for` `(p1 = head1; p1 != NULL; p1 = p1->next)`   `        ``// for each node of 1st list` `        ``// traverse the 2nd list`   `        ``for` `(p2 = head2; p2 != NULL; p2 = p2->next)`   `            ``// if sum of pair is equal to 'x'` `            ``// increment count` `            ``if` `((p1->data + p2->data) == x)` `                ``count++;            ` `        `  `    ``// required count of pairs     ` `    ``return` `count;` `}`   `// Driver program to test above` `int` `main()` `{` `    ``struct` `Node* head1 = NULL;` `    ``struct` `Node* head2 = NULL;` `    `  `    ``// create linked list1 3->1->5->7` `    ``push(&head1, 7);` `    ``push(&head1, 5);` `    ``push(&head1, 1);` `    ``push(&head1, 3);    ` `    `  `    ``// create linked list2 8->2->5->3` `    ``push(&head2, 3);` `    ``push(&head2, 5);` `    ``push(&head2, 2);` `    ``push(&head2, 8);` `    `  `    ``int` `x = 10;` `    `  `    ``cout << ``"Count = "` `         ``<< countPairs(head1, head2, x);` `    ``return` `0;` `}`

## Java

 `// Java implementation to count pairs from both linked ` `// lists  whose sum is equal to a given value`   `// Note : here we use java.util.LinkedList for ` `// linked list implementation`   `import` `java.util.Arrays;` `import` `java.util.Iterator;` `import` `java.util.LinkedList;`   `class` `GFG ` `{` `    ``// method to count all pairs from both the linked lists` `    ``// whose sum is equal to a given value` `    ``static` `int` `countPairs(LinkedList head1, LinkedList head2, ``int` `x)` `    ``{` `        ``int` `count = ``0``;` `         `  `        ``// traverse the 1st linked list` `        ``Iterator itr1 = head1.iterator();` `        ``while``(itr1.hasNext())` `        ``{` `            ``// for each node of 1st list` `            ``// traverse the 2nd list` `            ``Iterator itr2 = head2.iterator();` `            ``Integer t = itr1.next();` `            ``while``(itr2.hasNext())` `            ``{` `                ``// if sum of pair is equal to 'x'` `                ``// increment count` `                ``if` `((t + itr2.next()) == x)` `                    ``count++; ` `            ``}` `        ``}` `                           `  `        ``// required count of pairs     ` `        ``return` `count;` `    ``}` `    `  `    ``// Driver method` `    ``public` `static` `void` `main(String[] args) ` `    ``{` `        ``Integer arr1[] = {``3``, ``1``, ``5``, ``7``};` `        ``Integer arr2[] = {``8``, ``2``, ``5``, ``3``};` `        `  `        ``// create linked list1 3->1->5->7` `        ``LinkedList head1 = ``new` `LinkedList<>(Arrays.asList(arr1));` `        `  `        ``// create linked list2 8->2->5->3` `        ``LinkedList head2 = ``new` `LinkedList<>(Arrays.asList(arr2));` `       `  `        ``int` `x = ``10``;` `         `  `        ``System.out.println(``"Count = "` `+ countPairs(head1, head2, x));` `    ``}    ` `}`

## Python3

 `# Python3 implementation to count pairs from both linked ` `# lists whose sum is equal to a given value`   `# A Linked list node ` `class` `Node: ` `    ``def` `__init__(``self``,data): ` `        ``self``.data ``=` `data ` `        ``self``.``next` `=` `None`   `# function to insert a node at the` `# beginning of the linked list`   `def` `push(head_ref,new_data):` `    ``new_node``=``Node(new_data)` `    ``#new_node.data = new_data` `    ``new_node.``next` `=` `head_ref` `    ``head_ref ``=` `new_node` `    ``return` `head_ref`     `# function to count all pairs from both the linked lists` `# whose sum is equal to a given value` `def` `countPairs(head1, head2, x):` `    ``count ``=` `0` `    `  `    ``#struct Node p1, p2` `    `  `    ``# traverse the 1st linked list` `    ``p1 ``=` `head1` `    ``while``(p1 !``=` `None``):`   `        ``# for each node of 1st list` `        ``# traverse the 2nd list` `        ``p2 ``=` `head2` `        ``while``(p2 !``=` `None``):`   `            ``# if sum of pair is equal to 'x'` `            ``# increment count` `            ``if` `((p1.data ``+` `p2.data) ``=``=` `x):` `                ``count``+``=``1` `            ``p2 ``=` `p2.``next` `            `  `        ``p1 ``=` `p1.``next` `    ``# required count of pairs     ` `    ``return` `count`     `# Driver program to test above` `if` `__name__``=``=``'__main__'``: `   `    ``head1 ``=` `None` `    ``head2 ``=` `None` `    `  `    ``# create linked list1 3.1.5.7` `    ``head1``=``push(head1, ``7``)` `    ``head1``=``push(head1, ``5``)` `    ``head1``=``push(head1, ``1``)` `    ``head1``=``push(head1, ``3``) ` `    `  `    ``# create linked list2 8.2.5.3` `    ``head2``=``push(head2, ``3``)` `    ``head2``=``push(head2, ``5``)` `    ``head2``=``push(head2, ``2``)` `    ``head2``=``push(head2, ``8``)` `    `  `    ``x ``=` `10` `    `  `    ``print``(``"Count = "``,countPairs(head1, head2, x))` `    `  `# This code is contributed by AbhiThakur`

## C#

 `// C# implementation to count pairs from both linked ` `// lists whose sum is equal to a given value` `using` `System;` `using` `System.Collections.Generic; ` `    `    `// Note : here we use using System.Collections.Generic for ` `// linked list implementation` `class` `GFG ` `{` `    ``// method to count all pairs from both the linked lists` `    ``// whose sum is equal to a given value` `    ``static` `int` `countPairs(List<``int``> head1, List<``int``> head2, ``int` `x)` `    ``{` `        ``int` `count = 0;` `        `  `        ``// traverse the 1st linked list` `        `  `        ``foreach``(``int` `itr1 ``in` `head1)` `        ``{` `            ``// for each node of 1st list` `            ``// traverse the 2nd list` `            ``int` `t = itr1;` `            ``foreach``(``int` `itr2 ``in` `head2)` `            ``{` `                ``// if sum of pair is equal to 'x'` `                ``// increment count` `                ``if` `((t + itr2) == x)` `                    ``count++; ` `            ``}` `        ``}` `                            `  `        ``// required count of pairs     ` `        ``return` `count;` `    ``}` `    `  `    ``// Driver code` `    ``public` `static` `void` `Main(String []args) ` `    ``{` `        ``int` `[]arr1 = {3, 1, 5, 7};` `        ``int` `[]arr2 = {8, 2, 5, 3};` `        `  `        ``// create linked list1 3->1->5->7` `        ``List<``int``> head1 = ``new` `List<``int``>(arr1);` `        `  `        ``// create linked list2 8->2->5->3` `        ``List<``int``> head2 = ``new` `List<``int``>(arr2);` `        `  `        ``int` `x = 10;` `        `  `    ``Console.WriteLine(``"Count = "` `+ countPairs(head1, head2, x));` `    ``} ` `}`   `// This code is contributed by 29AjayKumar `

## Javascript

 ``

Output

`Count = 2`

Time Complexity: O(n1*n2)
Auxiliary Space: O(1)

Method 2 (Sorting): Sort the 1st linked list in ascending order and the 2nd linked list in descending order using merge sort technique. Now traverse both the lists from left to right in the following way:

Algorithm:

```countPairs(list1, list2, x)
Initialize count = 0
while list1 != NULL and list2 != NULL
if (list1->data + list2->data) == x
list1 = list1->next
list2 = list2->next
count++
else if (list1->data + list2->data) > x
list2 = list2->next
else
list1 = list1->next

return count     ```

For simplicity, the implementation given below assumes that list1 is sorted in ascending order and list2 is sorted in descending order.

Implementation:

## C++

 `// C++ implementation to count pairs from both linked ` `// lists  whose sum is equal to a given value` `#include ` `using` `namespace` `std;`   `/* A Linked list node */` `struct` `Node` `{` `  ``int` `data;` `  ``struct` `Node* next;` `};`   `// function to insert a node at the` `// beginning of the linked list` `void` `push(``struct` `Node** head_ref, ``int` `new_data)` `{` `  ``/* allocate node */` `  ``struct` `Node* new_node =` `          ``(``struct` `Node*) ``malloc``(``sizeof``(``struct` `Node));` ` `  `  ``/* put in the data  */` `  ``new_node->data  = new_data;` ` `  `  ``/* link the old list to the new node */` `  ``new_node->next = (*head_ref);` ` `  `  ``/* move the head to point to the new node */` `  ``(*head_ref)    = new_node;` `}`   `// function to count all pairs from both the linked ` `// lists whose sum is equal to a given value` `int` `countPairs(``struct` `Node* head1, ``struct` `Node* head2,` `                                              ``int` `x)` `{` `    ``int` `count = 0;` `    `  `    ``// sort head1 in ascending order and` `    ``// head2 in descending order` `    ``// sort (head1), sort (head2)` `    ``// For simplicity both lists are considered to be ` `    ``// sorted in the respective orders` `    `  `    ``// traverse both the lists from left to right` `    ``while` `(head1 != NULL && head2 != NULL)` `    ``{` `        ``// if this sum is equal to 'x', then move both ` `        ``// the lists to next nodes and increment 'count'` `        ``if` `((head1->data + head2->data) == x)` `        ``{` `            ``head1 = head1->next;` `            ``head2 = head2->next;` `            ``count++;    ` `        ``}    ` `        `  `        ``// if this sum is greater than x, then` `        ``// move head2 to next node` `        ``else` `if` `((head1->data + head2->data) > x)` `            ``head2 = head2->next;` `            `  `        ``// else move head1 to next node    ` `        ``else` `            ``head1 = head1->next;` `    ``}        ` `        `  `    ``// required count of pairs     ` `    ``return` `count;` `}`   `// Driver program to test above` `int` `main()` `{` `    ``struct` `Node* head1 = NULL;` `    ``struct` `Node* head2 = NULL;` `    `  `    ``// create linked list1 1->3->5->7` `    ``// assumed to be in ascending order` `    ``push(&head1, 7);` `    ``push(&head1, 5);` `    ``push(&head1, 3);` `    ``push(&head1, 1);    ` `    `  `    ``// create linked list2 8->5->3->2` `    ``// assumed to be in descending order` `    ``push(&head2, 2);` `    ``push(&head2, 3);` `    ``push(&head2, 5);` `    ``push(&head2, 8);` `    `  `    ``int` `x = 10;` `    `  `    ``cout << ``"Count = "` `         ``<< countPairs(head1, head2, x);` `    ``return` `0;` `}`

## Java

 `// Java implementation to count pairs from both linked ` `// lists  whose sum is equal to a given value`   `// Note : here we use java.util.LinkedList for ` `// linked list implementation`   `import` `java.util.Arrays;` `import` `java.util.Collections;` `import` `java.util.Iterator;` `import` `java.util.LinkedList;`   `class` `GFG ` `{` `    ``// method to count all pairs from both the linked lists` `    ``// whose sum is equal to a given value` `    ``static` `int` `countPairs(LinkedList head1, LinkedList head2, ``int` `x)` `    ``{` `        ``int` `count = ``0``;` `         `  `        ``// sort head1 in ascending order and` `        ``// head2 in descending order` `        ``Collections.sort(head1);` `        ``Collections.sort(head2,Collections.reverseOrder());` `        `  `        ``// traverse both the lists from left to right` `        ``Iterator itr1 = head1.iterator();` `        ``Iterator itr2 = head2.iterator();` `        `  `        ``Integer num1 = itr1.hasNext() ? itr1.next() : ``null``;` `        ``Integer num2 = itr2.hasNext() ? itr2.next() : ``null``;` `        `  `        ``while``(num1 != ``null` `&& num2 != ``null``)` `        ``{     ` `            `  `            ``// if this sum is equal to 'x', then move both ` `            ``// the lists to next nodes and increment 'count'` `            `  `            ``if` `((num1 + num2) == x)` `            ``{` `                ``num1 = itr1.hasNext() ? itr1.next() : ``null``;` `                ``num2 = itr2.hasNext() ? itr2.next() : ``null``;` `                `  `                ``count++; ` `            ``} ` `            `  `            ``// if this sum is greater than x, then` `            ``// move itr2 to next node` `            ``else` `if` `((num1 + num2) > x)` `                ``num2 = itr2.hasNext() ? itr2.next() : ``null``;` `            `  `            ``// else move itr1 to next node ` `            ``else` `                ``num1 = itr1.hasNext() ? itr1.next() : ``null``;` `            `  `        ``}` `                           `  `        ``// required count of pairs     ` `        ``return` `count;` `    ``}` `    `  `    ``// Driver method` `    ``public` `static` `void` `main(String[] args) ` `    ``{` `        ``Integer arr1[] = {``3``, ``1``, ``5``, ``7``};` `        ``Integer arr2[] = {``8``, ``2``, ``5``, ``3``};` `        `  `        ``// create linked list1 3->1->5->7` `        ``LinkedList head1 = ``new` `LinkedList<>(Arrays.asList(arr1));` `        `  `        ``// create linked list2 8->2->5->3` `        ``LinkedList head2 = ``new` `LinkedList<>(Arrays.asList(arr2));` `       `  `        ``int` `x = ``10``;` `         `  `        ``System.out.println(``"Count = "` `+ countPairs(head1, head2, x));` `    ``}    ` `}`

## Javascript

 `// JavaScript implementation to count pairs from both linked ` `// lists whose sum is equal to a given value`   `// A Linked List Node` `class Node{` `    ``constructor(data){` `        ``this``.data = data;` `        ``this``.next = ``null``;` `    ``}` `}`   `// Function to insert a node at the ` `// beginning o the linked list` `function` `push(head_ref, new_data){` `    ``// allocate node and put in the data` `    ``let new_node = ``new` `Node(new_data);` `    `  `    ``// link the old list to the new node` `    ``new_node.next = head_ref;` `    `  `    ``// move the head to point to the new node` `    ``head_ref = new_node;` `    ``return` `head_ref;` `}`   `// function to count all pairs from both the linked ` `// lists whose sum is equal to a given value` `function` `countPairs(head1, head2, x){` `    ``let count = 0;` `    `  `    ``// sort head1 in ascending order and` `    ``// head2 in descending order` `    ``// sort (head1), sort (head2)` `    ``// For simplicity both lists are considered to be ` `    ``// sorted in the respective orders` `      `  `    ``// traverse both the lists from left to right` `    ``while``(head1 != ``null` `&& head2 != ``null``){` `        ``// if this sum is equal to 'x', then move both ` `        ``// the lists to next nodes and increment 'count'` `        ``if``(head1.data + head2.data == x){` `            ``head1 = head1.next;` `            ``head2 = head2.next;` `            ``count++;` `        ``}` `        ``// if this sum is greater than x, then` `        ``// move head2 to next node` `        ``else` `if``(head1.data + head2.data > x)` `            ``head2 = head2.next;` `        `  `        ``// else move head1 to next node` `        ``else` `            ``head1 = head1.next;` `    `  `    ``// required count of pairs` `    ``}` `    ``return` `count;` `}`   `// Driver program to test above` `let head1 = ``null``;` `let head2 = ``null``;`   `// create linked list1 1->3->5->7` `// assumed to be in ascending order` `head1 = push(head1, 7);` `head1 = push(head1, 5);` `head1 = push(head1, 3);` `head1 = push(head1, 1);`   `// create linked list2 8->5->3->2` `// assumed to be in descending order` `head2 = push(head2, 2);` `head2 = push(head2, 3);` `head2 = push(head2, 5);` `head2 = push(head2, 8);`   `let x = 10;` `console.log(``"Count = "` `+ countPairs(head1, head2, x));`   `// This code is contributed by Yash Agarwal(yashagarwal2852002)`

Output

`Count = 2`

Time Complexity: O(n1*logn1) + O(n2*logn2)
Auxiliary Space: O(1)

Sorting will change the order of nodes. If order is important, then copy of the linked lists can be created and used.

Method 3 (Hashing): Hash table is implemented using unordered_set in C++. We store all first linked list elements in hash table. For elements of second linked list, we subtract every element from x and check the result in hash table. If result is present, we increment the count.

Implementation:

## C++

 `// C++ implementation to count pairs from both linked  ` `// lists whose sum is equal to a given value` `#include ` `using` `namespace` `std;`   `/* A Linked list node */` `struct` `Node` `{` `  ``int` `data;` `  ``struct` `Node* next;` `};`   `// function to insert a node at the` `// beginning of the linked list` `void` `push(``struct` `Node** head_ref, ``int` `new_data)` `{` `  ``/* allocate node */` `  ``struct` `Node* new_node =` `          ``(``struct` `Node*) ``malloc``(``sizeof``(``struct` `Node));` ` `  `  ``/* put in the data  */` `  ``new_node->data  = new_data;` ` `  `  ``/* link the old list to the new node */` `  ``new_node->next = (*head_ref);` ` `  `  ``/* move the head to point to the new node */` `  ``(*head_ref)    = new_node;` `}`   `// function to count all pairs from both the linked ` `// lists whose sum is equal to a given value` `int` `countPairs(``struct` `Node* head1, ``struct` `Node* head2, ` `                                               ``int` `x)` `{` `    ``int` `count = 0;` `    `  `    ``unordered_set<``int``> us;` `    `  `    ``// insert all the elements of 1st list` `    ``// in the hash table(unordered_set 'us')` `    ``while` `(head1 != NULL)` `    ``{` `        ``us.insert(head1->data);    ` `        `  `        ``// move to next node    ` `        ``head1 = head1->next;` `    ``}` `    `  `    ``// for each element of 2nd list` `    ``while` `(head2 != NULL)    ` `    ``{` `        ``// find (x - head2->data) in 'us'` `        ``if` `(us.find(x - head2->data) != us.end())` `            ``count++;` `        `  `        ``// move to next node` `        ``head2 = head2->next;    ` `    ``}` `    ``// required count of pairs     ` `    ``return` `count;` `}`   `// Driver program to test above` `int` `main()` `{` `    ``struct` `Node* head1 = NULL;` `    ``struct` `Node* head2 = NULL;` `    `  `    ``// create linked list1 3->1->5->7` `    ``push(&head1, 7);` `    ``push(&head1, 5);` `    ``push(&head1, 1);` `    ``push(&head1, 3);    ` `    `  `    ``// create linked list2 8->2->5->3` `    ``push(&head2, 3);` `    ``push(&head2, 5);` `    ``push(&head2, 2);` `    ``push(&head2, 8);` `    `  `    ``int` `x = 10;` `    `  `    ``cout << ``"Count = "` `         ``<< countPairs(head1, head2, x);` `    ``return` `0;` `}`

## Java

 `// Java implementation to count pairs from both linked ` `// lists  whose sum is equal to a given value`   `// Note : here we use java.util.LinkedList for ` `// linked list implementation`   `import` `java.util.Arrays;` `import` `java.util.HashSet;` `import` `java.util.Iterator;` `import` `java.util.LinkedList;`   `class` `GFG ` `{` `    ``// method to count all pairs from both the linked lists` `    ``// whose sum is equal to a given value` `    ``static` `int` `countPairs(LinkedList head1, LinkedList head2, ``int` `x)` `    ``{` `        ``int` `count = ``0``;` `         `  `        ``HashSet us = ``new` `HashSet();` `         `  `        ``// insert all the elements of 1st list` `        ``// in the hash table(unordered_set 'us')` `        ``Iterator itr1 = head1.iterator();` `        ``while` `(itr1.hasNext())` `        ``{` `            ``us.add(itr1.next());    ` `           `  `        ``}` `        `  `        ``Iterator itr2 = head2.iterator();` `        ``// for each element of 2nd list` `        ``while` `(itr2.hasNext())    ` `        ``{` `            ``// find (x - head2->data) in 'us'` `            ``if` `(!(us.add(x - itr2.next())))` `                ``count++;` `               `  `        ``}` `        `  `        ``// required count of pairs     ` `        ``return` `count;` `    ``}` `    `  `    ``// Driver method` `    ``public` `static` `void` `main(String[] args) ` `    ``{` `        ``Integer arr1[] = {``3``, ``1``, ``5``, ``7``};` `        ``Integer arr2[] = {``8``, ``2``, ``5``, ``3``};` `        `  `        ``// create linked list1 3->1->5->7` `        ``LinkedList head1 = ``new` `LinkedList<>(Arrays.asList(arr1));` `        `  `        ``// create linked list2 8->2->5->3` `        ``LinkedList head2 = ``new` `LinkedList<>(Arrays.asList(arr2));` `       `  `        ``int` `x = ``10``;` `         `  `        ``System.out.println(``"Count = "` `+ countPairs(head1, head2, x));` `    ``}    ` `}`

## Python3

 `# Python3 implementation to count pairs from both linked  ` `# lists whose sum is equal to a given value` ` `  `''' A Linked list node '''` `class` `Node:` `    `  `    ``def` `__init__(``self``):` `        ``self``.data ``=` `0` `        ``self``.``next` `=` `None` `  `  `# function to add a node at the` `# beginning of the linked list` `def` `push(head_ref, new_data):`   `  ``''' allocate node '''` `  ``new_node ``=``Node()` `  `  `  ``''' put in the data  '''` `  ``new_node.data  ``=` `new_data;` `  `  `  ``''' link the old list to the new node '''` `  ``new_node.``next` `=` `(head_ref);` `  `  `  ``''' move the head to point to the new node '''` `  ``(head_ref) ``=` `new_node;` `  `  `  ``return` `head_ref`   `# function to count all pairs from both the linked ` `# lists whose sum is equal to a given value` `def` `countPairs(head1, head2, x):` `    ``count ``=` `0``;    ` `    ``us ``=` `set``() ` `     `  `    ``# add all the elements of 1st list` `    ``# in the hash table(unordered_set 'us')` `    ``while` `(head1 !``=` `None``):   ` `        ``us.add(head1.data);    ` `         `  `        ``# move to next node    ` `        ``head1 ``=` `head1.``next``;` `     `  `    ``# for each element of 2nd list` `    ``while` `(head2 !``=` `None``):  ` `    `  `        ``# find (x - head2.data) in 'us'` `        ``if` `((x ``-` `head2.data) ``in` `us):` `            ``count ``+``=` `1` `         `  `        ``# move to next node` `        ``head2 ``=` `head2.``next``;    ` `    `  `    ``# required count of pairs     ` `    ``return` `count;` ` `  `# Driver program to test above` `if` `__name__``=``=``'__main__'``:` `    `  `    ``head1 ``=` `None``;` `    ``head2 ``=` `None``;` `     `  `    ``# create linked list1 3.1.5.7` `    ``head1 ``=` `push(head1, ``7``);` `    ``head1 ``=` `push(head1, ``5``);` `    ``head1 ``=` `push(head1, ``1``);` `    ``head1 ``=` `push(head1, ``3``);    ` `     `  `    ``# create linked list2 8.2.5.3` `    ``head2 ``=` `push(head2, ``3``);` `    ``head2 ``=` `push(head2, ``5``);` `    ``head2 ``=` `push(head2, ``2``);` `    ``head2 ``=` `push(head2, ``8``);` `     `  `    ``x ``=` `10``;` `     `  `    ``print``(``"Count ="``, countPairs(head1, head2, x));` `    `  `# This code is contributed by rutvik_56`

## C#

 `// C# implementation to count pairs from both linked ` `// lists whose sum is equal to a given value`   `// Note : here we use java.util.LinkedList for ` `// linked list implementation` `using` `System;` `using` `System.Collections.Generic;`   `class` `GFG ` `{` `    ``// method to count all pairs from both the linked lists` `    ``// whose sum is equal to a given value` `    ``static` `int` `countPairs(List<``int``> head1, List<``int``> head2, ``int` `x)` `    ``{` `        ``int` `count = 0;` `        `  `        ``HashSet<``int``> us = ``new` `HashSet<``int``>();` `        `  `        ``// insert all the elements of 1st list` `        ``// in the hash table(unordered_set 'us')` `        ``foreach``(``int` `itr1 ``in` `head1)` `        ``{` `            ``us.Add(itr1); ` `            `  `        ``}`   `        ``// for each element of 2nd list` `        ``foreach``(``int` `itr2 ``in` `head2) ` `        ``{` `            ``// find (x - head2->data) in 'us'` `            ``if` `(!(us.Contains(x - itr2)))` `                ``count++;` `                `  `        ``}` `        `  `        ``// required count of pairs     ` `        ``return` `count;` `    ``}` `    `  `    ``// Driver code` `    ``public` `static` `void` `Main(String[] args) ` `    ``{` `        ``int` `[]arr1 = {3, 1, 5, 7};` `        ``int` `[]arr2 = {8, 2, 5, 3};` `        `  `        ``// create linked list1 3->1->5->7` `        ``List<``int``> head1 = ``new` `List<``int``>(arr1);` `        `  `        ``// create linked list2 8->2->5->3` `        ``List<``int``> head2 = ``new` `List<``int``>(arr2);` `        `  `        ``int` `x = 10;` `        `  `        ``Console.WriteLine(``"Count = "` `+ countPairs(head1, head2, x));` `    ``} ` `}`   `// This code is contributed by Princi Singh`

## Javascript

 ``

Output

`Count = 2`

Time Complexity: O(n1 + n2)
Auxiliary Space: O(n1), hash table should be created of the array having smaller size so as to reduce the space complexity.

This article is contributed by Ayush Jauhari. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

My Personal Notes arrow_drop_up
Related Articles