# Count pairs in a binary tree whose sum is equal to a given value x

Given a binary tree containing n distinct numbers and a value x. The problem is to count pairs in the given binary tree whose sum is equal to the given value x.

Examples:

```Input :
5
/ \
3   7
/ \ / \
2  4 6  8

x = 10

Output : 3
The pairs are (3, 7), (2, 8) and (4, 6).
```

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

1) Naive Approach: One by one get each node of the binary tree through any of the tree traversals method. Pass the node say temp, the root of the tree and value x to another function say findPair(). In the function with the help of the root pointer traverse the tree again. One by one sum up these nodes with temp and check whether sum == x. If so, increment count. Calculate count = count / 2 as a single pair has been counted twice by the aforementioned method.

## C++

 `// C++ implementation to count pairs in a binary tree ` `// whose sum is equal to given value x ` `#include ` `using` `namespace` `std; ` ` `  `// structure of a node of a binary tree ` `struct` `Node { ` `    ``int` `data; ` `    ``Node *left, *right; ` `}; ` ` `  `// function to create and return a node ` `// of a binary tree ` `Node* getNode(``int` `data) ` `{ ` `    ``// allocate space for the node ` `    ``Node* new_node = (Node*)``malloc``(``sizeof``(Node)); ` ` `  `    ``// put in the data ` `    ``new_node->data = data; ` `    ``new_node->left = new_node->right = NULL; ` `} ` ` `  `// returns true if a pair exists with given sum 'x' ` `bool` `findPair(Node* root, Node* temp, ``int` `x) ` `{ ` `    ``// base case ` `    ``if` `(!root) ` `        ``return` `false``; ` ` `  `    ``// pair exists ` `    ``if` `(root != temp && ((root->data + temp->data) == x)) ` `        ``return` `true``; ` ` `  `    ``// find pair in left and right subtress ` `    ``if` `(findPair(root->left, temp, x) || findPair(root->right, temp, x)) ` `        ``return` `true``; ` ` `  `    ``// pair does not exists with given sum 'x' ` `    ``return` `false``; ` `} ` ` `  `// function to count pairs in a binary tree ` `// whose sum is equal to given value x ` `void` `countPairs(Node* root, Node* curr, ``int` `x, ``int``& count) ` `{ ` `    ``// if tree is empty ` `    ``if` `(!curr) ` `        ``return``; ` ` `  `    ``// check whether pair exists for current node 'curr' ` `    ``// in the binary tree that sum up to 'x' ` `    ``if` `(findPair(root, curr, x)) ` `        ``count++; ` ` `  `    ``// recursively count pairs in left subtree ` `    ``countPairs(root, curr->left, x, count); ` ` `  `    ``// recursively count pairs in right subtree ` `    ``countPairs(root, curr->right, x, count); ` `} ` ` `  `// Driver program to test above ` `int` `main() ` `{ ` `    ``// formation of binary tree ` `    ``Node* root = getNode(5); ``/*        5      */` `    ``root->left = getNode(3); ``/*       / \      */` `    ``root->right = getNode(7); ``/*    3   7      */` `    ``root->left->left = getNode(2); ``/*   / \ / \   */` `    ``root->left->right = getNode(4); ``/*   2 4 6 8   */` `    ``root->right->left = getNode(6); ` `    ``root->right->right = getNode(8); ` ` `  `    ``int` `x = 10; ` `    ``int` `count = 0; ` ` `  `    ``countPairs(root, root, x, count); ` `    ``count = count / 2; ` ` `  `    ``cout << ``"Count = "` `<< count; ` ` `  `    ``return` `0; ` `} `

## Java

 `// Java implementation to count pairs in a binary tree ` `// whose sum is equal to given value x ` `import` `java.util.*; ` ` `  `class` `GFG ` `{ ` ` `  `// structure of a node of a binary tree ` `static` `class` `Node  ` `{ ` `    ``int` `data; ` `    ``Node left, right; ` `}; ` `static` `int` `count; ` ` `  `// function to create and return a node ` `// of a binary tree ` `static` `Node getNode(``int` `data) ` `{ ` `    ``// allocate space for the node ` `    ``Node new_node = ``new` `Node(); ` ` `  `    ``// put in the data ` `    ``new_node.data = data; ` `    ``new_node.left = new_node.right = ``null``; ` `    ``return` `new_node; ` `} ` ` `  `// returns true if a pair exists with given sum 'x' ` `static` `boolean` `findPair(Node root, Node temp, ``int` `x) ` `{ ` `    ``// base case ` `    ``if` `(root==``null``) ` `        ``return` `false``; ` ` `  `    ``// pair exists ` `    ``if` `(root != temp && ((root.data + temp.data) == x)) ` `        ``return` `true``; ` ` `  `    ``// find pair in left and right subtress ` `    ``if` `(findPair(root.left, temp, x) ||  ` `           ``findPair(root.right, temp, x)) ` `        ``return` `true``; ` ` `  `    ``// pair does not exists with given sum 'x' ` `    ``return` `false``; ` `} ` ` `  `// function to count pairs in a binary tree ` `// whose sum is equal to given value x ` `static` `void` `countPairs(Node root, Node curr, ``int` `x) ` `{ ` `    ``// if tree is empty ` `    ``if` `(curr == ``null``) ` `        ``return``; ` ` `  `    ``// check whether pair exists for current node 'curr' ` `    ``// in the binary tree that sum up to 'x' ` `    ``if` `(findPair(root, curr, x)) ` `        ``count++; ` ` `  `    ``// recursively count pairs in left subtree ` `    ``countPairs(root, curr.left, x); ` ` `  `    ``// recursively count pairs in right subtree ` `    ``countPairs(root, curr.right, x); ` `} ` ` `  `// Driver code ` `public` `static` `void` `main(String[] args) ` `{ ` `    ``// formation of binary tree ` `    ``Node root = getNode(``5``); ``/*     5     */` `    ``root.left = getNode(``3``); ``/*     / \     */` `    ``root.right = getNode(``7``); ``/* 3 7     */` `    ``root.left.left = getNode(``2``); ``/* / \ / \ */` `    ``root.left.right = getNode(``4``); ``/* 2 4 6 8 */` `    ``root.right.left = getNode(``6``); ` `    ``root.right.right = getNode(``8``); ` ` `  `    ``int` `x = ``10``; ` `    ``count = ``0``; ` ` `  `    ``countPairs(root, root, x); ` `    ``count = count / ``2``; ` ` `  `    ``System.out.print(``"Count = "` `+ count); ` `} ` `} ` ` `  `// This code is contributed by PrinciRaj1992 `

## Python3

 `# Python3 implementation to count pairs in a binary tree ` `# whose sum is equal to given value x ` ` `  `# structure of a node of a binary tree ` `class` `getNode(``object``): ` `    ``def` `__init__(``self``, value): ` `        ``self``.data ``=` `value ` `        ``self``.left ``=` `None` `        ``self``.right ``=` `None` ` `  `# returns True if a pair exists with given sum 'x' ` `def` `findPair(root, temp, x): ` `    ``# base case ` `    ``if` `root ``=``=` `None``: ` `        ``return` `False` `         `  `    ``# pair exists ` `    ``if` `(root !``=` `temp ``and` `((root.data ``+` `temp.data) ``=``=` `x)): ` `        ``return` `True` `         `  `    ``# find pair in left and right subtress ` `    ``if` `(findPair(root.left, temp, x) ``or` `findPair(root.right, temp, x)): ` `        ``return` `True` `         `  `    ``# pair does not exists with given sum 'x' ` `    ``return` `False` `     `  `# function to count pairs in a binary tree ` `# whose sum is equal to given value x ` `def` `countPairs(root, curr, x): ` `    ``global` `count ` `     `  `    ``# if tree is empty ` `    ``if` `curr ``=``=` `None``: ` `        ``return` `     `  `    ``# check whether pair exists for current node 'curr' ` `    ``# in the binary tree that sum up to 'x' ` `    ``if` `(findPair(root, curr, x)): ` `        ``count ``+``=` `1` `         `  `    ``# recursively count pairs in left subtree ` `    ``countPairs(root, curr.left, x) ` `     `  `    ``# recursively count pairs in right subtree ` `    ``countPairs(root, curr.right, x) ` ` `  `# Driver program to test above ` `# formation of binary tree ` `root ``=` `getNode(``5``)     ` `root.left ``=` `getNode(``3``)  ` `root.right ``=` `getNode(``7``)  ` `root.left.left ``=` `getNode(``2``)  ` `root.left.right ``=` `getNode(``4``) ` `root.right.left ``=` `getNode(``6``) ` `root.right.right ``=` `getNode(``8``) ` `x ``=` `10` `count ``=` `0` ` `  `countPairs(root, root, x) ` `count ``=` `count ``/``/` `2` ` `  `print``(``"Count ="``, count) ` ` `  `# This code is contributed by shubhamsingh10 `

## C#

 `// C# implementation to count pairs in a binary tree ` `// whose sum is equal to given value x ` `using` `System; ` ` `  `class` `GFG ` `{ ` ` `  `// structure of a node of a binary tree ` `class` `Node  ` `{ ` `    ``public` `int` `data; ` `    ``public` `Node left, right; ` `}; ` `static` `int` `count; ` ` `  `// function to create and return a node ` `// of a binary tree ` `static` `Node getNode(``int` `data) ` `{ ` `    ``// allocate space for the node ` `    ``Node new_node = ``new` `Node(); ` ` `  `    ``// put in the data ` `    ``new_node.data = data; ` `    ``new_node.left = new_node.right = ``null``; ` `    ``return` `new_node; ` `} ` ` `  `// returns true if a pair exists with given sum 'x' ` `static` `bool` `findPair(Node root, Node temp, ``int` `x) ` `{ ` `    ``// base case ` `    ``if` `(root == ``null``) ` `        ``return` `false``; ` ` `  `    ``// pair exists ` `    ``if` `(root != temp && ((root.data + temp.data) == x)) ` `        ``return` `true``; ` ` `  `    ``// find pair in left and right subtress ` `    ``if` `(findPair(root.left, temp, x) ||  ` `        ``findPair(root.right, temp, x)) ` `        ``return` `true``; ` ` `  `    ``// pair does not exists with given sum 'x' ` `    ``return` `false``; ` `} ` ` `  `// function to count pairs in a binary tree ` `// whose sum is equal to given value x ` `static` `void` `countPairs(Node root, Node curr, ``int` `x) ` `{ ` `    ``// if tree is empty ` `    ``if` `(curr == ``null``) ` `        ``return``; ` ` `  `    ``// check whether pair exists for current node 'curr' ` `    ``// in the binary tree that sum up to 'x' ` `    ``if` `(findPair(root, curr, x)) ` `        ``count++; ` ` `  `    ``// recursively count pairs in left subtree ` `    ``countPairs(root, curr.left, x); ` ` `  `    ``// recursively count pairs in right subtree ` `    ``countPairs(root, curr.right, x); ` `} ` ` `  `// Driver code ` `public` `static` `void` `Main(String[] args) ` `{ ` `    ``// formation of binary tree ` `    ``Node root = getNode(5); ``/*     5     */` `    ``root.left = getNode(3); ``/*     / \     */` `    ``root.right = getNode(7); ``/* 3 7     */` `    ``root.left.left = getNode(2); ``/* / \ / \ */` `    ``root.left.right = getNode(4); ``/* 2 4 6 8 */` `    ``root.right.left = getNode(6); ` `    ``root.right.right = getNode(8); ` ` `  `    ``int` `x = 10; ` `    ``count = 0; ` ` `  `    ``countPairs(root, root, x); ` `    ``count = count / 2; ` ` `  `    ``Console.Write(``"Count = "` `+ count); ` `} ` `} ` ` `  `// This code is contributed by Rajput-Ji `

Output:

```Count = 3
```

Time Complexity: O(n^2).

2) Efficient Approach: Following are the steps:

1. Convert given binary tree to doubly linked list. Refer this post.
2. Sort the doubly linked list obtained in Step 1. Refer this post.
3. Count Pairs in sorted doubly linked with sum equal to ‘x’. Refer this post.
4. Display the count obtained in Step 4.

## C++

 `// C++ implementation to count pairs in a binary tree ` `// whose sum is equal to given value x ` `#include ` `using` `namespace` `std; ` ` `  `// structure of a node of a binary tree ` `struct` `Node { ` `    ``int` `data; ` `    ``Node *left, *right; ` `}; ` ` `  `// function to create and return a node ` `// of a binary tree ` `Node* getNode(``int` `data) ` `{ ` `    ``// allocate space for the node ` `    ``Node* new_node = (Node*)``malloc``(``sizeof``(Node)); ` ` `  `    ``// put in the data ` `    ``new_node->data = data; ` `    ``new_node->left = new_node->right = NULL; ` `} ` ` `  `// A simple recursive function to convert a given ` `// Binary tree to Doubly Linked List ` `// root     --> Root of Binary Tree ` `// head_ref --> Pointer to head node of created ` `// doubly linked list ` `void` `BToDLL(Node* root, Node** head_ref) ` `{ ` `    ``// Base cases ` `    ``if` `(root == NULL) ` `        ``return``; ` ` `  `    ``// Recursively convert right subtree ` `    ``BToDLL(root->right, head_ref); ` ` `  `    ``// insert root into DLL ` `    ``root->right = *head_ref; ` ` `  `    ``// Change left pointer of previous head ` `    ``if` `(*head_ref != NULL) ` `        ``(*head_ref)->left = root; ` ` `  `    ``// Change head of Doubly linked list ` `    ``*head_ref = root; ` ` `  `    ``// Recursively convert left subtree ` `    ``BToDLL(root->left, head_ref); ` `} ` ` `  `// Split a doubly linked list (DLL) into 2 DLLs of ` `// half sizes ` `Node* split(Node* head) ` `{ ` `    ``Node *fast = head, *slow = head; ` `    ``while` `(fast->right && fast->right->right) { ` `        ``fast = fast->right->right; ` `        ``slow = slow->right; ` `    ``} ` `    ``Node* temp = slow->right; ` `    ``slow->right = NULL; ` `    ``return` `temp; ` `} ` ` `  `// Function to merge two sorted doubly linked lists ` `Node* merge(Node* first, Node* second) ` `{ ` `    ``// If first linked list is empty ` `    ``if` `(!first) ` `        ``return` `second; ` ` `  `    ``// If second linked list is empty ` `    ``if` `(!second) ` `        ``return` `first; ` ` `  `    ``// Pick the smaller value ` `    ``if` `(first->data < second->data) { ` `        ``first->right = merge(first->right, second); ` `        ``first->right->left = first; ` `        ``first->left = NULL; ` `        ``return` `first; ` `    ``} ` `    ``else` `{ ` `        ``second->right = merge(first, second->right); ` `        ``second->right->left = second; ` `        ``second->left = NULL; ` `        ``return` `second; ` `    ``} ` `} ` ` `  `// Function to do merge sort ` `Node* mergeSort(Node* head) ` `{ ` `    ``if` `(!head || !head->right) ` `        ``return` `head; ` `    ``Node* second = split(head); ` ` `  `    ``// Recur for left and right halves ` `    ``head = mergeSort(head); ` `    ``second = mergeSort(second); ` ` `  `    ``// Merge the two sorted halves ` `    ``return` `merge(head, second); ` `} ` ` `  `// Function to count pairs in a sorted doubly linked list ` `// whose sum equal to given value x ` `int` `pairSum(Node* head, ``int` `x) ` `{ ` `    ``// Set two pointers, first to the beginning of DLL ` `    ``// and second to the end of DLL. ` `    ``Node* first = head; ` `    ``Node* second = head; ` `    ``while` `(second->right != NULL) ` `        ``second = second->right; ` ` `  `    ``int` `count = 0; ` ` `  `    ``// The loop terminates when either of two pointers ` `    ``// become NULL, or they cross each other (second->right ` `    ``// == first), or they become same (first == second) ` `    ``while` `(first != NULL && second != NULL && first != second && second->right != first) { ` `        ``// pair found ` `        ``if` `((first->data + second->data) == x) { ` `            ``count++; ` ` `  `            ``// move first in forward direction ` `            ``first = first->right; ` ` `  `            ``// move second in backward direction ` `            ``second = second->left; ` `        ``} ` `        ``else` `{ ` `            ``if` `((first->data + second->data) < x) ` `                ``first = first->right; ` `            ``else` `                ``second = second->left; ` `        ``} ` `    ``} ` ` `  `    ``return` `count; ` `} ` ` `  `// function to count pairs in a binary tree ` `// whose sum is equal to given value x ` `int` `countPairs(Node* root, ``int` `x) ` `{ ` `    ``Node* head = NULL; ` `    ``int` `count = 0; ` ` `  `    ``// Convert binary tree to ` `    ``// doubly linked list ` `    ``BToDLL(root, &head); ` ` `  `    ``// sort DLL ` `    ``head = mergeSort(head); ` ` `  `    ``// count pairs ` `    ``return` `pairSum(head, x); ` `} ` ` `  `// Driver program to test above ` `int` `main() ` `{ ` `    ``// formation of binary tree ` `    ``Node* root = getNode(5); ``/*        5      */` `    ``root->left = getNode(3); ``/*       / \      */` `    ``root->right = getNode(7); ``/*    3   7      */` `    ``root->left->left = getNode(2); ``/*   / \ / \   */` `    ``root->left->right = getNode(4); ``/*   2 4 6 8   */` `    ``root->right->left = getNode(6); ` `    ``root->right->right = getNode(8); ` ` `  `    ``int` `x = 10; ` ` `  `    ``cout << ``"Count = "` `         ``<< countPairs(root, x); ` ` `  `    ``return` `0; ` `} `

## Java

 `// Java implementation to count pairs  ` `// in a binary tree whose sum is equal to ` `// given value x ` `class` `GFG  ` `{ ` ` `  `    ``// structure of a node of a binary tree ` `    ``static` `class` `Node  ` `    ``{ ` `        ``int` `data; ` `        ``Node left, right; ` `    ``}; ` ` `  `    ``static` `Node head_ref; ` ` `  `    ``// function to create and return a node ` `    ``// of a binary tree ` `    ``static` `Node getNode(``int` `data)  ` `    ``{ ` `        ``// allocate space for the node ` `        ``Node new_node = ``new` `Node(); ` ` `  `        ``// put in the data ` `        ``new_node.data = data; ` `        ``new_node.left = new_node.right = ``null``; ` `        ``return` `new_node; ` `    ``} ` ` `  `    ``// A simple recursive function to convert  ` `    ``// a given Binary tree to Doubly Linked List ` `    ``// root -. Root of Binary Tree ` `    ``// head_ref -. Pointer to head node of created ` `    ``// doubly linked list ` `    ``static` `void` `BToDLL(Node root)  ` `    ``{ ` `        ``// Base cases ` `        ``if` `(root == ``null``) ` `            ``return``; ` ` `  `        ``// Recursively convert right subtree ` `        ``BToDLL(root.right); ` ` `  `        ``// insert root into DLL ` `        ``root.right = head_ref; ` ` `  `        ``// Change left pointer of previous head ` `        ``if` `(head_ref != ``null``) ` `            ``head_ref.left = root; ` ` `  `        ``// Change head of Doubly linked list ` `        ``head_ref = root; ` ` `  `        ``// Recursively convert left subtree ` `        ``BToDLL(root.left); ` `    ``} ` ` `  `    ``// Split a doubly linked list (DLL)  ` `    ``// into 2 DLLs of half sizes ` `    ``static` `Node split(Node head) ` `    ``{ ` `        ``Node fast = head, slow = head; ` `        ``while` `(fast.right != ``null` `&&  ` `               ``fast.right.right != ``null``)  ` `        ``{ ` `            ``fast = fast.right.right; ` `            ``slow = slow.right; ` `        ``} ` `        ``Node temp = slow.right; ` `        ``slow.right = ``null``; ` `        ``return` `temp; ` `    ``} ` ` `  `    ``// Function to merge two sorted  ` `    ``// doubly linked lists ` `    ``static` `Node merge(Node first, Node second) ` `    ``{ ` `        ``// If first linked list is empty ` `        ``if` `(first == ``null``) ` `            ``return` `second; ` ` `  `        ``// If second linked list is empty ` `        ``if` `(second == ``null``) ` `            ``return` `first; ` ` `  `        ``// Pick the smaller value ` `        ``if` `(first.data < second.data)  ` `        ``{ ` `            ``first.right = merge(first.right, ` `                                ``second); ` `            ``first.right.left = first; ` `            ``first.left = ``null``; ` `            ``return` `first; ` `        ``}  ` `        ``else` `        ``{ ` `            ``second.right = merge(first,  ` `                                 ``second.right); ` `            ``second.right.left = second; ` `            ``second.left = ``null``; ` `            ``return` `second; ` `        ``} ` `    ``} ` ` `  `    ``// Function to do merge sort ` `    ``static` `Node mergeSort(Node head) ` `    ``{ ` `        ``if` `(head == ``null` `|| head.right == ``null``) ` `            ``return` `head; ` `        ``Node second = split(head); ` ` `  `        ``// Recur for left and right halves ` `        ``head = mergeSort(head); ` `        ``second = mergeSort(second); ` ` `  `        ``// Merge the two sorted halves ` `        ``return` `merge(head, second); ` `    ``} ` ` `  `    ``// Function to count pairs in a sorted  ` `    ``// doubly linked list whose sum equal  ` `    ``// to given value x ` `    ``static` `int` `pairSum(Node head, ``int` `x) ` `    ``{ ` `        ``// Set two pointers, first to the beginning  ` `        ``// of DLL and second to the end of DLL. ` `        ``Node first = head; ` `        ``Node second = head; ` `        ``while` `(second.right != ``null``) ` `            ``second = second.right; ` ` `  `        ``int` `count = ``0``; ` ` `  `        ``// The loop terminates when either of two pointers ` `        ``// become null, or they cross each other (second.right ` `        ``// == first), or they become same (first == second) ` `        ``while` `(first != ``null` `&& second != ``null` `&& ` `               ``first != second && second.right != first) ` `        ``{ ` `            ``// pair found ` `            ``if` `((first.data + second.data) == x) ` `            ``{ ` `                ``count++; ` ` `  `                ``// move first in forward direction ` `                ``first = first.right; ` ` `  `                ``// move second in backward direction ` `                ``second = second.left; ` `            ``}  ` `            ``else` `            ``{ ` `                ``if` `((first.data + second.data) < x) ` `                    ``first = first.right; ` `                ``else` `                    ``second = second.left; ` `            ``} ` `        ``} ` `        ``return` `count; ` `    ``} ` ` `  `    ``// function to count pairs in a binary tree ` `    ``// whose sum is equal to given value x ` `    ``static` `int` `countPairs(Node root, ``int` `x)  ` `    ``{ ` `        ``head_ref = ``null``; ` ` `  `        ``// Convert binary tree to ` `        ``// doubly linked list ` `        ``BToDLL(root); ` ` `  `        ``// sort DLL ` `        ``head_ref = mergeSort(head_ref); ` ` `  `        ``// count pairs ` `        ``return` `pairSum(head_ref, x); ` `    ``} ` ` `  `    ``// Driver Code ` `    ``public` `static` `void` `main(String[] args)  ` `    ``{ ` `        ``// formation of binary tree ` `        ``Node root = getNode(``5``); ``/* 5 */` `        ``root.left = getNode(``3``); ``/* / \ */` `        ``root.right = getNode(``7``); ``/* 3 7 */` `        ``root.left.left = getNode(``2``); ``/* / \ / \ */` `        ``root.left.right = getNode(``4``); ``/* 2 4 6 8 */` `        ``root.right.left = getNode(``6``); ` `        ``root.right.right = getNode(``8``); ` ` `  `        ``int` `x = ``10``; ` ` `  `        ``System.out.print(``"Count = "` `+  ` `                ``countPairs(root, x)); ` `    ``} ` `} ` ` `  `// This code is contributed by Rajput-Ji `

## C#

 `// C# implementation to count pairs  ` `// in a binary tree whose sum is  ` `// equal to the given value x ` `using` `System; ` ` `  `class` `GFG  ` `{ ` ` `  `    ``// structure of a node of a binary tree ` `    ``class` `Node  ` `    ``{ ` `        ``public` `int` `data; ` `        ``public` `Node left, right; ` `    ``}; ` ` `  `    ``static` `Node head_ref; ` ` `  `    ``// function to create and return a node ` `    ``// of a binary tree ` `    ``static` `Node getNode(``int` `data)  ` `    ``{ ` `        ``// allocate space for the node ` `        ``Node new_node = ``new` `Node(); ` ` `  `        ``// put in the data ` `        ``new_node.data = data; ` `        ``new_node.left = new_node.right = ``null``; ` `        ``return` `new_node; ` `    ``} ` ` `  `    ``// A simple recursive function to convert  ` `    ``// a given Binary tree to Doubly Linked List ` `    ``// root -. Root of Binary Tree ` `    ``// head_ref -. Pointer to head node of  ` `    ``// created doubly linked list ` `    ``static` `void` `BToDLL(Node root)  ` `    ``{ ` `        ``// Base cases ` `        ``if` `(root == ``null``) ` `            ``return``; ` ` `  `        ``// Recursively convert right subtree ` `        ``BToDLL(root.right); ` ` `  `        ``// insert root into DLL ` `        ``root.right = head_ref; ` ` `  `        ``// Change left pointer of previous head ` `        ``if` `(head_ref != ``null``) ` `            ``head_ref.left = root; ` ` `  `        ``// Change head of Doubly linked list ` `        ``head_ref = root; ` ` `  `        ``// Recursively convert left subtree ` `        ``BToDLL(root.left); ` `    ``} ` ` `  `    ``// Split a doubly linked list (DLL)  ` `    ``// into 2 DLLs of half sizes ` `    ``static` `Node split(Node head) ` `    ``{ ` `        ``Node fast = head, slow = head; ` `        ``while` `(fast.right != ``null` `&&  ` `               ``fast.right.right != ``null``)  ` `        ``{ ` `            ``fast = fast.right.right; ` `            ``slow = slow.right; ` `        ``} ` `        ``Node temp = slow.right; ` `        ``slow.right = ``null``; ` `        ``return` `temp; ` `    ``} ` ` `  `    ``// Function to merge two sorted  ` `    ``// doubly linked lists ` `    ``static` `Node merge(Node first, ` `                      ``Node second) ` `    ``{ ` `        ``// If first linked list is empty ` `        ``if` `(first == ``null``) ` `            ``return` `second; ` ` `  `        ``// If second linked list is empty ` `        ``if` `(second == ``null``) ` `            ``return` `first; ` ` `  `        ``// Pick the smaller value ` `        ``if` `(first.data < second.data)  ` `        ``{ ` `            ``first.right = merge(first.right, ` `                                ``second); ` `            ``first.right.left = first; ` `            ``first.left = ``null``; ` `            ``return` `first; ` `        ``}  ` `        ``else` `        ``{ ` `            ``second.right = merge(first,  ` `                                 ``second.right); ` `            ``second.right.left = second; ` `            ``second.left = ``null``; ` `            ``return` `second; ` `        ``} ` `    ``} ` ` `  `    ``// Function to do merge sort ` `    ``static` `Node mergeSort(Node head) ` `    ``{ ` `        ``if` `(head == ``null` `|| head.right == ``null``) ` `            ``return` `head; ` `        ``Node second = split(head); ` ` `  `        ``// Recur for left and right halves ` `        ``head = mergeSort(head); ` `        ``second = mergeSort(second); ` ` `  `        ``// Merge the two sorted halves ` `        ``return` `merge(head, second); ` `    ``} ` ` `  `    ``// Function to count pairs in a sorted  ` `    ``// doubly linked list whose sum equal  ` `    ``// to given value x ` `    ``static` `int` `pairSum(Node head, ``int` `x) ` `    ``{ ` `        ``// Set two pointers, first to the beginning  ` `        ``// of DLL and second to the end of DLL. ` `        ``Node first = head; ` `        ``Node second = head; ` `        ``while` `(second.right != ``null``) ` `            ``second = second.right; ` ` `  `        ``int` `count = 0; ` ` `  `        ``// The loop terminates when either of  ` `        ``// two pointers become null, or they  ` `        ``// cross each other (second.right == first), ` `        ``// or they become same (first == second) ` `        ``while` `(first != ``null` `&& second != ``null` `&& ` `               ``first != second && second.right != first) ` `        ``{ ` `            ``// pair found ` `            ``if` `((first.data + second.data) == x) ` `            ``{ ` `                ``count++; ` ` `  `                ``// move first in forward direction ` `                ``first = first.right; ` ` `  `                ``// move second in backward direction ` `                ``second = second.left; ` `            ``}  ` `            ``else` `            ``{ ` `                ``if` `((first.data + second.data) < x) ` `                    ``first = first.right; ` `                ``else` `                    ``second = second.left; ` `            ``} ` `        ``} ` `        ``return` `count; ` `    ``} ` ` `  `    ``// function to count pairs in a binary tree ` `    ``// whose sum is equal to given value x ` `    ``static` `int` `countPairs(Node root, ``int` `x)  ` `    ``{ ` `        ``head_ref = ``null``; ` ` `  `        ``// Convert binary tree to ` `        ``// doubly linked list ` `        ``BToDLL(root); ` ` `  `        ``// sort DLL ` `        ``head_ref = mergeSort(head_ref); ` ` `  `        ``// count pairs ` `        ``return` `pairSum(head_ref, x); ` `    ``} ` ` `  `    ``// Driver Code ` `    ``public` `static` `void` `Main(String[] args)  ` `    ``{ ` `        ``// formation of binary tree ` `        ``Node root = getNode(5);         ``/* 5 */` `        ``root.left = getNode(3);         ``/* / \ */` `        ``root.right = getNode(7);     ``/* 3 7 */` `        ``root.left.left = getNode(2); ``/* / \ / \ */` `        ``root.left.right = getNode(4); ``/* 2 4 6 8 */` `        ``root.right.left = getNode(6); ` `        ``root.right.right = getNode(8); ` ` `  `        ``int` `x = 10; ` ` `  `        ``Console.Write(``"Count = "` `+  ` `                ``countPairs(root, x)); ` `    ``} ` `} ` ` `  `// This code is contributed by Rajput-Ji `

Output:

```Count = 3
```

Time Complexity: O(nLog n).

3)Another Efficient Approach – No need for converting to DLL and sorting: Following are the steps:

1. Traverse the tree in any order (pre / post / in).
2. Create an empty hash and keep adding difference between current node’s value and X to it.
3. At each node, check if it’s value is in the hash, if yes then increment the count by 1 and DO NOT add this node’s value’s difference with X in the hash to avoid duplicate counting for a single pair.

 `# Python program to Count pairs  ` `# in a binary tree whose sum is  ` `# equal to a given value x ` ` `  `# Node class to represent a ` `# node in the binary tree  ` `# with value, left and right attributes ` `class` `Node(``object``): ` `    ``def` `__init__(``self``, value, left ``=` `None``, right ``=` `None``): ` `        ``self``.value ``=` `value ` `        ``self``.left ``=` `left ` `        ``self``.right ``=` `right ` ` `  `# To store count of pairs ` `count ``=` `0` ` `  `# To store difference between  ` `# current node's value and x, ` `# acts a lookup for counting pairs ` `hash_t ``=` `set``() ` ` `  `# The input, we need to count  ` `# pairs whose sum is equal to x ` `x ``=` `10` ` `  `# Function to count number of pairs ` `# Does a pre-order traversal of the tree ` `def` `count_pairs_w_sum(root): ` `    ``# global count ` `    ``if` `root: ` `        ``if` `root.value ``in` `hash_t: ` `            ``count ``+``=` `1` `        ``else``: ` `            ``hash_t.add(x``-``root.value) ` `         `  `        ``count_pairs_w_sum(root.left) ` `        ``count_pairs_w_sum(root.right) ` ` `  `# Entry point / Driver - Create a  ` `# binary tree and call the function  ` `# to get the count ` `if` `__name__ ``=``=` `'__main__'``: ` `    ``root ``=` `Node(``5``) ` `     `  `    ``root.left ``=` `Node(``3``) ` `    ``root.right ``=` `Node(``7``) ` `     `  `    ``root.left.left ``=` `Node(``2``) ` `    ``root.left.right ``=` `Node(``4``) ` `     `  `    ``root.right.left ``=` `Node(``6``) ` `    ``root.right.right ``=` `Node(``8``) ` `     `  `    ``count_pairs_w_sum(root) ` `     `  `    ``print` `count `

Output:

```Count = 3
```

Time Complexity: O(n)
Space Complexity: O(n)

GeeksforGeeks has prepared a complete interview preparation course with premium videos, theory, practice problems, TA support and many more features. Please refer Placement 100 for details

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.