Related Articles
Number of pairs with a given sum in a Binary Search Tree
• Difficulty Level : Medium
• Last Updated : 20 Jan, 2020

Given a Binary Search Tree, and a number X. The task is to find the number of distinct pairs of distinct nodes in BST with a sum equal to X. No two nodes have the same values.

Examples:

```
Input : X = 5
5
/   \
3     7
/ \   / \
2   4 6   8
Output : 1
{2, 3} is the only possible pair.
Thus, the answer is equal to 1.

Input : X = 6
1
\
2
\
3
\
4
\
5

Output : 2
Possible pairs are {{1, 5}, {2, 4}}.
```

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

Naive Approach: The idea is to hash all the elements of BST or convert the BST to a sorted array. After that find the number of pairs using the algorithm given here.
Time Complexity: O(N).
Space Complexity: O(N).

Space Optimized Approach : The idea is to use two pointer technique on BST. Maintain forward and backward iterators that will iterate the BST in the order of in-order and reverse in-order traversal respectively.

1. Create forward and backward iterators for BST. Let’s say that the value of nodes they are pointing at are equal to v1 and v2 respectively.
2. Now at each step,
• If v1 + v2 = X, the pair is found, thus increase the count by 1.
• If v1 + v2 is less than or equal to x, we will make forward iterator point to the next element.
• If v1 + v2 is greater than x, we will make backward iterator point to the previous element.
3. Repeat the above steps untill both iterators don’t point to the same node.

Below is the implementation of the above approach:

## C++

 `// C++ implementation of the approach``#include ``using` `namespace` `std;`` ` `// Node of Binary tree``struct` `node {``    ``int` `data;``    ``node* left;``    ``node* right;``    ``node(``int` `data)``    ``{``        ``this``->data = data;``        ``left = NULL;``        ``right = NULL;``    ``}``};`` ` `// Function to find a pair``int` `cntPairs(node* root, ``int` `x)``{``    ``// Stack to store nodes for``    ``// forward and backward iterator``    ``stack it1, it2;`` ` `    ``// Initializing forward iterator``    ``node* c = root;``    ``while` `(c != NULL)``        ``it1.push(c), c = c->left;`` ` `    ``// Initializing backward iterator``    ``c = root;``    ``while` `(c != NULL)``        ``it2.push(c), c = c->right;`` ` `    ``// Variable to store final answer``    ``int` `ans = 0;`` ` `    ``// two pointer technique``    ``while` `(it1.top() != it2.top()) {`` ` `        ``// Variables to store the``        ``// value of the nodes current``        ``// iterators are pointing to.``        ``int` `v1 = it1.top()->data;``        ``int` `v2 = it2.top()->data;`` ` `        ``// If we find a pair``        ``// then count is increased by 1``        ``if` `(v1 + v2 == x)``            ``ans++;`` ` `        ``// Moving forward iterator``        ``if` `(v1 + v2 <= x) {``            ``c = it1.top()->right;``            ``it1.pop();``            ``while` `(c != NULL)``                ``it1.push(c), c = c->left;``        ``}`` ` `        ``// Moving backward iterator``        ``else` `{``            ``c = it2.top()->left;``            ``it2.pop();``            ``while` `(c != NULL)``                ``it2.push(c), c = c->right;``        ``}``    ``}`` ` `    ``// Returning final answer``    ``return` `ans;``}`` ` `// Driver code``int` `main()``{``    ``/*    5 ``        ``/   \ ``       ``3     7 ``      ``/ \   / \ ``     ``2   4 6   8 */``    ``node* root = ``new` `node(5);``    ``root->left = ``new` `node(3);``    ``root->right = ``new` `node(7);``    ``root->left->left = ``new` `node(2);``    ``root->left->right = ``new` `node(4);``    ``root->right->left = ``new` `node(6);``    ``root->right->right = ``new` `node(8);`` ` `    ``int` `x = 10;`` ` `    ``cout << cntPairs(root, x);`` ` `    ``return` `0;``}`

## Java

 `// Java implementation of the approach``import` `java.util.*;`` ` `class` `GFG``{`` ` `// Node of Binary tree``static` `class` `node``{``    ``int` `data;``    ``node left;``    ``node right;``    ``node(``int` `data)``    ``{``        ``this``.data = data;``        ``left = ``null``;``        ``right = ``null``;``    ``}``};`` ` `// Function to find a pair``static` `int` `cntPairs(node root, ``int` `x)``{``    ``// Stack to store nodes for``    ``// forward and backward iterator``    ``Stack it1 = ``new` `Stack<>();``    ``Stack it2 = ``new` `Stack<>();`` ` `    ``// Initializing forward iterator``    ``node c = root;``    ``while` `(c != ``null``)``    ``{``        ``it1.push(c);``        ``c = c.left;``    ``}`` ` `    ``// Initializing backward iterator``    ``c = root;``    ``while` `(c != ``null``)``    ``{``        ``it2.push(c);``        ``c = c.right;``    ``}``     ` `    ``// Variable to store final answer``    ``int` `ans = ``0``;`` ` `    ``// two pointer technique``    ``while` `(it1.peek() != it2.peek()) ``    ``{`` ` `        ``// Variables to store the``        ``// value of the nodes current``        ``// iterators are pointing to.``        ``int` `v1 = it1.peek().data;``        ``int` `v2 = it2.peek().data;`` ` `        ``// If we find a pair``        ``// then count is increased by 1``        ``if` `(v1 + v2 == x)``            ``ans++;`` ` `        ``// Moving forward iterator``        ``if` `(v1 + v2 <= x) ``        ``{``            ``c = it1.peek().right;``            ``it1.pop();``            ``while` `(c != ``null``)``            ``{``                ``it1.push(c);``                ``c = c.left;``            ``}``        ``}`` ` `        ``// Moving backward iterator``        ``else` `        ``{``            ``c = it2.peek().left;``            ``it2.pop();``            ``while` `(c != ``null``)``            ``{``                ``it2.push(c);``                ``c = c.right;``            ``}``        ``}``    ``}`` ` `    ``// Returning final answer``    ``return` `ans;``}`` ` `// Driver code``public` `static` `void` `main(String[] args)``{``    ``/* 5 ``        ``/ \ ``    ``3     7 ``    ``/ \ / \ ``    ``2 4 6 8 */``    ``node root = ``new` `node(``5``);``    ``root.left = ``new` `node(``3``);``    ``root.right = ``new` `node(``7``);``    ``root.left.left = ``new` `node(``2``);``    ``root.left.right = ``new` `node(``4``);``    ``root.right.left = ``new` `node(``6``);``    ``root.right.right = ``new` `node(``8``);`` ` `    ``int` `x = ``10``;`` ` `    ``System.out.print(cntPairs(root, x));``}``}`` ` `// This code is contributed by Rajput-Ji`

## Python

 `# Python implementation of above algorithm`` ` `# Utility class to create a node ``class` `node: ``    ``def` `__init__(``self``, key): ``        ``self``.data ``=` `key ``        ``self``.left ``=` `self``.right ``=` `None`` ` `# Function to find a pair``def` `cntPairs( root, x):`` ` `    ``# Stack to store nodes for``    ``# forward and backward iterator``    ``it1 ``=` `[]``    ``it2 ``=` `[]`` ` `    ``# Initializing forward iterator``    ``c ``=` `root``    ``while` `(c !``=` `None``):``        ``it1.append(c)``        ``c ``=` `c.left`` ` `    ``# Initializing backward iterator``    ``c ``=` `root``    ``while` `(c !``=` `None``):``        ``it2.append(c)``        ``c ``=` `c.right`` ` `    ``# Variable to store final answer``    ``ans ``=` `0`` ` `    ``# two pointer technique``    ``while` `(it1[``-``1``] !``=` `it2[``-``1``]) :`` ` `        ``# Variables to store the``        ``# value of the nodes current``        ``# iterators are pointing to.``        ``v1 ``=` `it1[``-``1``].data``        ``v2 ``=` `it2[``-``1``].data`` ` `        ``# If we find a pair``        ``# then count is increased by 1``        ``if` `(v1 ``+` `v2 ``=``=` `x):``            ``ans``=``ans``+``1`` ` `        ``# Moving forward iterator``        ``if` `(v1 ``+` `v2 <``=` `x) :``            ``c ``=` `it1[``-``1``].right``            ``it1.pop()``            ``while` `(c !``=` `None``):``                ``it1.append(c)``                ``c ``=` `c.left``         ` `        ``# Moving backward iterator``        ``else` `:``            ``c ``=` `it2[``-``1``].left``            ``it2.pop()``            ``while` `(c !``=` `None``):``                ``it2.append(c)``                ``c ``=` `c.right``         ` `    ``# Returning final answer``    ``return` `ans`` ` `# Driver code`` ` `#         5 ``#     / \ ``#     3     7 ``#     / \ / \ ``#     2 4 6 8 ``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``)`` ` `x ``=` `10`` ` `print``(cntPairs(root, x))`` ` `# This code is contributed by Arnab Kundu`

## C#

 `// C# implementation of the approach``using` `System;``using` `System.Collections.Generic;`` ` `class` `GFG``{`` ` `// Node of Binary tree``public` `class` `node``{``    ``public` `int` `data;``    ``public` `node left;``    ``public` `node right;``    ``public` `node(``int` `data)``    ``{``        ``this``.data = data;``        ``left = ``null``;``        ``right = ``null``;``    ``}``};`` ` `// Function to find a pair``static` `int` `cntPairs(node root, ``int` `x)``{``    ``// Stack to store nodes for``    ``// forward and backward iterator``    ``Stack it1 = ``new` `Stack();``    ``Stack it2 = ``new` `Stack();`` ` `    ``// Initializing forward iterator``    ``node c = root;``    ``while` `(c != ``null``)``    ``{``        ``it1.Push(c);``        ``c = c.left;``    ``}`` ` `    ``// Initializing backward iterator``    ``c = root;``    ``while` `(c != ``null``)``    ``{``        ``it2.Push(c);``        ``c = c.right;``    ``}``     ` `    ``// Variable to store readonly answer``    ``int` `ans = 0;`` ` `    ``// two pointer technique``    ``while` `(it1.Peek() != it2.Peek()) ``    ``{`` ` `        ``// Variables to store the``        ``// value of the nodes current``        ``// iterators are pointing to.``        ``int` `v1 = it1.Peek().data;``        ``int` `v2 = it2.Peek().data;`` ` `        ``// If we find a pair``        ``// then count is increased by 1``        ``if` `(v1 + v2 == x)``            ``ans++;`` ` `        ``// Moving forward iterator``        ``if` `(v1 + v2 <= x) ``        ``{``            ``c = it1.Peek().right;``            ``it1.Pop();``            ``while` `(c != ``null``)``            ``{``                ``it1.Push(c);``                ``c = c.left;``            ``}``        ``}`` ` `        ``// Moving backward iterator``        ``else``        ``{``            ``c = it2.Peek().left;``            ``it2.Pop();``            ``while` `(c != ``null``)``            ``{``                ``it2.Push(c);``                ``c = c.right;``            ``}``        ``}``    ``}`` ` `    ``// Returning readonly answer``    ``return` `ans;``}`` ` `// Driver code``public` `static` `void` `Main(String[] args)``{``    ``/* 5 ``        ``/ \ ``    ``3     7 ``    ``/ \ / \ ``    ``2 4 6 8 */``    ``node root = ``new` `node(5);``    ``root.left = ``new` `node(3);``    ``root.right = ``new` `node(7);``    ``root.left.left = ``new` `node(2);``    ``root.left.right = ``new` `node(4);``    ``root.right.left = ``new` `node(6);``    ``root.right.right = ``new` `node(8);`` ` `    ``int` `x = 10;`` ` `    ``Console.Write(cntPairs(root, x));``}``}`` ` `// This code is contributed by Rajput-Ji`
Output:
```3
```

Time complexity: O(N)
Space complexity: O(H) where H is the height of BST

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.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with industry experts, please refer Geeks Classes Live and Geeks Classes Live USA

My Personal Notes arrow_drop_up