# FIND PAIR SUM

Hard.

#### Problem Statement :

Given a sorted singly linked list and a value K, the task is to find pair whose sum is equal to K. We are not allowed to use any extra space and expected time complexity is O`(`n`)`.
Print the number of pairs whose sum equals to `K`.

See original problem statement here

#### Example:

``````5 5
1 2 3 4 5

Output:2
Since the pairs (2,3) and (1,4) add to give 5.``````

## Approach 1`(Brute force):`

Iterate over each node and check if any corresponding node with data sum-node->data is present.
This costs O(n*n) time.

``` int count_pair(Node* head, int sum)
{
while (p != NULL) {
q = p->next;
while (q != NULL) {
if ((p->data) + (q->data) == sum) {
count++;
}
q = q->next;
}
p = p->next;
}
return count;
}
```
``` import java.util.*;

class prepbytes
{
static class Node
{
int data,count=0;
Node next;
};
static Node push(Node head_ref, int new_data)
{
Node new_node = new Node();
new_node.data = new_data;
}
static boolean check_pair_sum(Node head, int sum)
{
while (p != null)
{
q = p.next;
while (q != null)
{
if ((p.data) + (q.data) == sum)
{
count++;
return true;
}
q = q.next;
}
p = p.next;
}
return false;
}
//main
}
```

## Approach 2`(Hashing):`

Use hashtable(preferably map or set in C++) and initialize counter as 0.Insert the node data as you iterate over the list.If the corresponding node with data sum-node->data is found ,counter increases by one.

TIME COMPLEXITY:O(n)

`````` int count_pair(Node* head, int sum)
{
set<int> s;

while (p != NULL) {
int curr = p->data;
if (s.find(sum - curr) != s.end())
count++;
s.insert(p->data);
p = p->next;
}
return count;
} ``````

# Without using extra space!!!

Have you heard of `MEMORY EFFICIENT DOUBLY LINKED LISTS`in data structures and algorithms tutorials??????

`XOR Linked list` : In singly linked list, we can traverse list only in forward direction. We use XOR concept to convert a singly linked list to doubly linked list.

ALGO:

``````        First we need to convert our singly linked list into doubly linked list.

Here we are given singly linked list structure node which have only next pointer not prev pointer,

so to convert our singly linked list into doubly linked list we use memory efficient doubly linked list ( XOR linked list ).

In XOR linked list each next pointer of singly linked list contains XOR of next and prev pointer.

we initialize two pointers variables to find the candidate elements in the sorted doubly linked list. Initialize first with start of doubly linked list i.e;
first = head and initialize second with last node of doubly linked list i.e; second = last_node.

Here we don’t have random access, so to initialize pointer, we traverse the list till last node and assign last node to second.

If current sum of first and second is less than x, then we move first in forward direction.
If current sum of first and second element is greater than x, then we move second in backward direction.

Loop termination conditions are also different from arrays.
The loop terminates when either of two pointers become NULL, or they cross each other (first=next_node),
or they become same (first == second).
``````
```struct Node* XOR (struct Node *a, struct Node *b)
{
return (struct Node*) ((uintptr_t) (a) ^ (uintptr_t) (b));
}

// Utility function to convert singly linked list
// into XOR doubly linked list
{
// first we store address of next node in it
// then take XOR of next node and previous node
// and store it in next pointer
struct Node *next_node;

// prev node stores the address of previously
// visited node
struct Node *prev = NULL;

// traverse list and store xor of address of
// next_node and prev node in next pointer of node
{

// xor of next_node and prev node

// update previous node

}
}

// function to Find pair whose sum is equal to
// given value x
void pairSum(struct Node *head, int x)
{
// initialize first

// next_node and prev node to calculate xor again
// and find next and prev node while moving forward
// and backward direction from both the corners
struct Node *next_node = NULL, *prev = NULL;

// traverse list to initialize second pointer
// here we need to move in forward direction so to
// calculate next address we have to take xor
// with prev pointer because (a^b)^b = a
while (second->next != prev)
{
struct Node *temp = second;
second = XOR(second->next, prev);
prev = temp;
}

// now traverse from both the corners
next_node = NULL;
prev = NULL;

// here if we want to move forward then we must
// know the prev address to calculate next node
// and if we want to move backward then we must
// know the next_node address to calculate prev node
bool flag = false;
while (first != NULL && second != NULL &&
first != second && first != next_node)
{
if ((first->data + second->data)==x)
{
count++;
//increment the counter
flag = true;

// move first in forward
struct Node *temp = first;
first = XOR(first->next,prev);
prev = temp;

// move second in backward
temp = second;
second = XOR(second->next, next_node);
next_node = temp;
}
else
{
if ((first->data + second->data) < x)
{
// move first in forward
struct Node *temp = first;
first = XOR(first->next,prev);
prev = temp;
}
else
{
// move second in backward
struct Node *temp = second;
second = XOR(second->next, next_node);
next_node = temp;
}
}
}
}
```