Given a linked list, and a number, check if their exist two numbers whose sum is equal to given number. If there exist two numbers, print them. If there are multiple answer, print any of them.

Examples:

```Input : 1 -> 2 -> 3 -> 4 -> 5 -> NULL
sum = 3
Output : Pair is (1, 2)

Input : 10 -> 12 -> 31 -> 42 -> 53 -> NULL
sum = 15
Output : NO PAIR EXIST
```

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Method(Brute force)
Iteratively check if their exist any pair or not

## C++

 `// CPP code to find the pair with given sum ` `#include ` `using` `namespace` `std; ` ` `  `/* Link list node */` `struct` `Node { ` `    ``int` `data; ` `    ``struct` `Node* next; ` `}; ` ` `  `/* Given a reference (pointer to pointer) ` `    ``to the head of a list and an int, ` `    ``push a new node on the front  ` `    ``of the 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 off the new node */` `    ``new_node->next = (*head_ref); ` ` `  `    ``/* move the head to point to the new node */` `    ``(*head_ref) = new_node; ` `} ` ` `  `/* Takes head pointer of the linked list and sum*/` `int` `check_pair_sum(``struct` `Node* head, ``int` `sum) ` `{ ` `    ``struct` `Node* p = head, *q; ` `    ``while` `(p != NULL) { ` `     `  `        ``q = p->next; ` `        ``while` `(q != NULL) { ` ` `  `           ``// check if both sum is equal to ` `           ``// given sum ` `           ``if` `((p->data) + (q->data) == sum) { ` `               ``cout << p->data << ``" "` `<< q->data; ` `               ``return` `true``; ` `           ``}      ` `           ``q = q->next;           ` `        ``} ` ` `  `        ``p = p->next; ` `    ``} ` ` `  `    ``return` `0; ` `} ` ` `  `/* Driver program to test above function */` `int` `main() ` `{ ` `    ``/* Start with the empty list */` `    ``struct` `Node* head = NULL; ` ` `  `    ``/* Use push() to construct linked list*/` `    ``push(&head, 1); ` `    ``push(&head, 4); ` `    ``push(&head, 1); ` `    ``push(&head, 12); ` `    ``push(&head, 1); ` `    ``push(&head, 18); ` `    ``push(&head, 47); ` `    ``push(&head, 16); ` `    ``push(&head, 12); ` `    ``push(&head, 14); ` ` `  `    ``/* function to print the result*/` `    ``bool` `res = check_pair_sum(head, 26); ` `    ``if` `(res == ``false``) ` `        ``cout << ``"NO PAIR EXIST"``; ` ` `  `    ``return` `0; ` `} `

## Java

 `// Java code to find the pair with given sum ` `import` `java.util.*; ` ` `  `class` `GFG ` `{ ` ` `  `/* Link list node */` `static` `class` `Node  ` `{ ` `    ``int` `data; ` `    ``Node next; ` `}; ` `static` `Node head; ` ` `  `/* Given a reference (pointer to pointer) ` `    ``to the head of a list and an int, ` `    ``push a new node on the front  ` `    ``of the list. */` `// Inserting node at the beginning ` `static` `Node push(Node head_ref, ``int` `new_data) ` `{ ` `    ``/* allocate node */` `    ``Node new_node = ``new` `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=head_ref; ` `} ` ` `  `/* Takes head pointer of the linked list and sum*/` `static` `boolean` `check_pair_sum(Node head, ``int` `sum) ` `{ ` `    ``Node p = head, q; ` `    ``while` `(p != ``null``) ` `    ``{ ` `        ``q = p.next; ` `        ``while` `(q != ``null``)  ` `        ``{ ` ` `  `            ``// check if both sum is equal to ` `            ``// given sum ` `            ``if` `((p.data) + (q.data) == sum)  ` `            ``{ ` `                ``System.out.print(p.data + ``" "` `+ ` `                                 ``q.data); ` `                ``return` `true``; ` `            ``}      ` `            ``q = q.next;          ` `        ``} ` `        ``p = p.next; ` `    ``} ` `    ``return` `false``; ` `} ` ` `  `// Driver Code ` `public` `static` `void` `main(String[] args) ` `{ ` `    ``/* Start with the empty list */` `    ``head = ``null``; ` ` `  `    ``/* Use push() to conlinked list*/` `    ``push(head, ``1``); ` `    ``push(head, ``4``); ` `    ``push(head, ``1``); ` `    ``push(head, ``12``); ` `    ``push(head, ``1``); ` `    ``push(head, ``18``); ` `    ``push(head, ``47``); ` `    ``push(head, ``16``); ` `    ``push(head, ``12``); ` `    ``push(head, ``14``); ` ` `  `    ``/* function to print the result*/` `    ``boolean` `res = check_pair_sum(head, ``26``); ` `    ``if` `(res == ``false``) ` `        ``System.out.print(``"NO PAIR EXIST"``); ` `} ` `} ` ` `  `// This code is contributed by 29AjayKumar `

## Python3

 `# Python3 program for finding the pair with given sum ` `import` `math ` `import` `sys ` ` `  `# Link list node # ` `class` `Node: ` `    ``def` `__init__(``self``,data): ` `        ``self``.data``=``data ` `        ``self``.``next``=``None` `# Given a reference (pointer to pointer) to the head  ` `# of a list and an int, push a new node on the front  ` `# of the list. ` ` `  `def` `push(head,data): ` `    ``if` `head ``=``=` `None``: ` `        ``return` `Node(data) ` `         `  `    ``# allocate node ` `    ``temp ``=` `Node(data) ` `     `  `    ``# link the old list off the new node  ` `    ``temp.``next` `=` `head ` `     `  `    ``# move the head to point to the new node  ` `    ``head ``=` `temp ` `    ``return` `head ` ` `  `# Takes head pointer of the linked list and sum ` `def` `check_pair_sum(head,_sum_): ` `    ``p ``=` `head ` `    ``q ``=` `None` `    ``while``(p): ` `        ``q ``=` `p.``next` `        ``while``(q): ` `            ``if` `p.data``+``q.data ``=``=``_sum_: ` `                ``print``(``"{} {}"``.``format``(p.data,q.data)) ` `                ``return` `True` `            ``q ``=` `q.``next` `        ``p ``=` `p.``next` `    ``return` `False` ` `  `# Driver program to test above function ` `if` `__name__``=``=``'__main__'``: ` ` `  `    ``# Start with the empty list ` `    ``head ``=` `None` ` `  `    ``# Use push() to construct linked list  ` `    ``head ``=` `push(head,``1``) ` `    ``head ``=` `push(head,``4``) ` `    ``head ``=` `push(head,``1``) ` `    ``head ``=` `push(head,``12``) ` `    ``head ``=` `push(head,``1``) ` `    ``head ``=` `push(head,``18``) ` `    ``head ``=` `push(head,``47``) ` `    ``head ``=` `push(head,``16``) ` `    ``head ``=` `push(head,``12``) ` `    ``head ``=` `push(head,``14``) ` ` `  `    ``# function to print the result ` `    ``res ``=` `check_pair_sum(head,``26``) ` `    ``if` `(res ``=``=` `False``): ` `        ``print``(``"NO PAIR EXIST"``) ` ` `  `# This code is contributed by Vikash Kumar 37 `

## C#

 `// C# code to find the pair with given sum ` `using` `System; ` ` `  `class` `GFG ` `{ ` ` `  `/* Link list node */` `public` `class` `Node  ` `{ ` `    ``public` `int` `data; ` `    ``public` `Node next; ` `}; ` `static` `Node head; ` ` `  `/* Given a reference (pointer to pointer) ` `    ``to the head of a list and an int, ` `    ``push a new node on the front  ` `    ``of the list. */` `     `  `// Inserting node at the beginning ` `static` `Node push(Node head_ref, ``int` `new_data) ` `{ ` `    ``/* allocate node */` `    ``Node new_node = ``new` `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=head_ref; ` `} ` ` `  `/* Takes head pointer of the linked list and sum*/` `static` `Boolean check_pair_sum(Node head, ``int` `sum) ` `{ ` `    ``Node p = head, q; ` `    ``while` `(p != ``null``) ` `    ``{ ` `        ``q = p.next; ` `        ``while` `(q != ``null``)  ` `        ``{ ` ` `  `            ``// check if both sum is equal to ` `            ``// given sum ` `            ``if` `((p.data) + (q.data) == sum)  ` `            ``{ ` `                ``Console.Write(p.data + ``" "` `+ ` `                              ``q.data); ` `                ``return` `true``; ` `            ``}      ` `            ``q = q.next;          ` `        ``} ` `        ``p = p.next; ` `    ``} ` `    ``return` `false``; ` `} ` ` `  `// Driver Code ` `public` `static` `void` `Main(String[] args) ` `{ ` `    ``/* Start with the empty list */` `    ``head = ``null``; ` ` `  `    ``/* Use push() to conlinked list*/` `    ``push(head, 1); ` `    ``push(head, 4); ` `    ``push(head, 1); ` `    ``push(head, 12); ` `    ``push(head, 1); ` `    ``push(head, 18); ` `    ``push(head, 47); ` `    ``push(head, 16); ` `    ``push(head, 12); ` `    ``push(head, 14); ` ` `  `    ``/* function to print the result*/` `    ``Boolean res = check_pair_sum(head, 26); ` `    ``if` `(res == ``false``) ` `        ``Console.Write(``"NO PAIR EXIST"``); ` `} ` `} ` ` `  `// This code is contributed by Rajput-Ji `

Output:

```14 12
```

Time complexity:O(n*n)

Method 2 (using hashing)
1. Take a hashtable and mark all element with zero
2. Iteratively mark all the element as 1 in hashtable which are present in linked list
3. Iteratively find sum-current element of linked list is present in hashtable or not

## C++

 `// CPP program to for finding the pair with given sum ` `#include ` `#define MAX 100000 ` `using` `namespace` `std; ` ` `  `/* Link list node */` `struct` `Node { ` `    ``int` `data; ` `    ``struct` `Node* next; ` `}; ` ` `  `/* Given a reference (pointer to pointer) to the head ` `    ``of a list and an int, push a new node on the front ` `    ``of the 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 off the new node */` `    ``new_node->next = (*head_ref); ` ` `  `    ``/* move the head to point to the new node */` `    ``(*head_ref) = new_node; ` `} ` ` `  `/* Takes head pointer of the linked list and sum*/` `bool` `check_pair_sum(``struct` `Node* head, ``int` `sum) ` `{ ` `    ``unordered_set<``int``> s; ` `    `  `    ``struct` `Node* p = head; ` `    ``while` `(p != NULL) { ` `        ``int` `curr = p->data; ` `        ``if` `(s.find(sum - curr) != s.end()) ` `        ``{ ` `           ``cout << curr << ``" "` `<< sum - curr; ` `           ``return` `true``; ` `        ``} ` `        ``s.insert(p->data); ` `        ``p = p->next; ` `    ``} ` ` `  `    ``return` `false``; ` `} ` ` `  `/* Driver program to test above function*/` `int` `main() ` `{ ` `    ``/* Start with the empty list */` `    ``struct` `Node* head = NULL; ` ` `  `    ``/* Use push() to construct linked list */` `    ``push(&head, 1); ` `    ``push(&head, 4); ` `    ``push(&head, 1); ` `    ``push(&head, 12); ` `    ``push(&head, 1); ` `    ``push(&head, 18); ` `    ``push(&head, 47); ` `    ``push(&head, 16); ` `    ``push(&head, 12); ` `    ``push(&head, 14); ` ` `  `    ``/* function to print the result*/` `    ``bool` `res = check_pair_sum(head, 26); ` `    ``if` `(res == ``false``) ` `        ``cout << ``"NO PAIR EXIST"``; ` ` `  `    ``return` `0; ` `} `

## Java

 `// Java program for finding  ` `// the pair with given sum ` `import` `java.util.*; ` `class` `GFG  ` `{  ` `static` `int` `MAX = ``100000``; ` ` `  `/* Link list node */` `static` `class` `Node  ` `{ ` `    ``int` `data; ` `    ``Node next; ` `}; ` ` `  `static` `Node head; ` ` `  `/* Given a reference (pointer to pointer)  ` `to the head of a list and an int,  ` `push a new node on the front of the list. */` `static` `void` `push(Node head_ref, ``int` `new_data) ` `{ ` `    ``/* allocate node */` `    ``Node new_node = ``new` `Node(); ` ` `  `    ``/* put in the data */` `    ``new_node.data = new_data; ` ` `  `    ``/* link the old list off the new node */` `    ``new_node.next = head_ref; ` ` `  `    ``/* move the head to point to the new node */` `    ``head_ref = new_node; ` `    ``head = head_ref; ` `} ` ` `  `/* Takes head pointer of the linked list and sum*/` `static` `boolean` `check_pair_sum(Node head, ``int` `sum) ` `{ ` `    ``HashSet s = ``new` `HashSet(); ` `     `  `    ``Node p = head; ` `    ``while` `(p != ``null``) ` `    ``{ ` `        ``int` `curr = p.data; ` `        ``if` `(s.contains(sum - curr)) ` `        ``{ ` `            ``System.out.print(curr + ``" "` `+ ` `                            ``(sum - curr)); ` `            ``return` `true``; ` `        ``} ` `        ``s.add(p.data); ` `        ``p = p.next; ` `    ``} ` ` `  `    ``return` `false``; ` `} ` ` `  `// Driver Code ` `public` `static` `void` `main(String[] args)  ` `{ ` `     `  `    ``/* Start with the empty list */` `    ``head = ``null``; ` ` `  `    ``/* Use push() to conlinked list */` `    ``push(head, ``1``); ` `    ``push(head, ``4``); ` `    ``push(head, ``1``); ` `    ``push(head, ``12``); ` `    ``push(head, ``1``); ` `    ``push(head, ``18``); ` `    ``push(head, ``47``); ` `    ``push(head, ``16``); ` `    ``push(head, ``12``); ` `    ``push(head, ``14``); ` ` `  `    ``/* function to print the result*/` `    ``boolean` `res = check_pair_sum(head, ``26``); ` `    ``if` `(res == ``false``) ` `        ``System.out.print(``"NO PAIR EXIST"``); ` `} ` `} ` ` `  `// This code is contributed by PrinciRaj1992  `

## C#

 `// C# program for finding  ` `// the pair with given sum ` `using` `System; ` `using` `System.Collections.Generic; ` ` `  `class` `GFG  ` `{  ` `static` `int` `MAX = 100000; ` ` `  `/* Link list node */` `public` `class` `Node  ` `{ ` `    ``public` `int` `data; ` `    ``public` `Node next; ` `}; ` ` `  `static` `Node head; ` ` `  `/* Given a reference (pointer to pointer)  ` `to the head of a list and an int,  ` `push a new node on the front of the list. */` `static` `void` `push(Node head_ref, ``int` `new_data) ` `{ ` `    ``/* allocate node */` `    ``Node new_node = ``new` `Node(); ` ` `  `    ``/* put in the data */` `    ``new_node.data = new_data; ` ` `  `    ``/* link the old list off the new node */` `    ``new_node.next = head_ref; ` ` `  `    ``/* move the head to point to the new node */` `    ``head_ref = new_node; ` `    ``head = head_ref; ` `} ` ` `  `/* Takes head pointer of the linked list and sum*/` `static` `Boolean check_pair_sum(Node head, ``int` `sum) ` `{ ` `    ``HashSet<``int``> s = ``new` `HashSet<``int``>(); ` `     `  `    ``Node p = head; ` `    ``while` `(p != ``null``) ` `    ``{ ` `        ``int` `curr = p.data; ` `        ``if` `(s.Contains(sum - curr)) ` `        ``{ ` `            ``Console.Write(curr + ``" "` `+ ` `                         ``(sum - curr)); ` `            ``return` `true``; ` `        ``} ` `        ``s.Add(p.data); ` `        ``p = p.next; ` `    ``} ` `    ``return` `false``; ` `} ` ` `  `// Driver Code ` `public` `static` `void` `Main(String[] args)  ` `{ ` `     `  `    ``/* Start with the empty list */` `    ``head = ``null``; ` ` `  `    ``/* Use push() to conlinked list */` `    ``push(head, 1); ` `    ``push(head, 4); ` `    ``push(head, 1); ` `    ``push(head, 12); ` `    ``push(head, 1); ` `    ``push(head, 18); ` `    ``push(head, 47); ` `    ``push(head, 16); ` `    ``push(head, 12); ` `    ``push(head, 14); ` ` `  `    ``/* function to print the result*/` `    ``Boolean res = check_pair_sum(head, 26); ` `    ``if` `(res == ``false``) ` `        ``Console.Write(``"NO PAIR EXIST"``); ` `} ` `} ` ` `  `// This code is contributed by Princi Singh `

Output:

```14 12
```

Time complexity : O(n)
Auxiliary Space : O(n)

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

My Personal Notes arrow_drop_up Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.

Article Tags :
Practice Tags :

Be the First to upvote.

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.