#### Concepts Used

Linked lists,hash table

#### Difficulty Level

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`

.

#### Example:

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

## EXPLANATION:

## 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) { Node* p = head, *q; 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 head; static Node push(Node head_ref, int new_data) { Node new_node = new Node(); new_node.data = new_data; new_node.next = head_ref; head_ref = new_node; return head=head_ref; } static boolean check_pair_sum(Node head, int sum) { Node p = head, q; 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;
Node* p = head;
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.
After converting singly linked list into doubly linked list
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 void convert(struct Node *head) { // 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 while (head != NULL) { // address of next node next_node = head->next; // xor of next_node and prev node head->next = XOR(next_node, prev); // update previous node prev = head; // move head forward head = next_node; } } // function to Find pair whose sum is equal to // given value x void pairSum(struct Node *head, int x) { // initialize first struct Node *first = head; // 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 struct Node *second = head; 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; } } } }