# Count pairs from two BSTs whose sum is equal to a given value x

Given two BSTs containing n1 and n2 distinct nodes respectively. Given a value x. The problem is to count all pairs from both the BSTs whose sum is equal to x.

Examples:

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

BST 2:    10
/   \
6     15
/ \   /  \
3  8  11  18
x = 16

Output : 3
The pairs are:
(5, 11), (6, 10) and (8, 8)
```

## Recommended: Please solve it on PRACTICE first, before moving on to the solution.

Method 1: For each node value a in BST 1, search the value (x – a) in BST 2. If value found then increment the count. For searching a value in BST, refer this post.
Time complexity: O(n1 * h2), here n1 is number of nodes in first BST and h2 is height of second BST.

Method 2: Traverse BST 1 from smallest value to node to largest. This can be achieved with the help of iterative inorder traversal. Traverse BST 2 from largest value node to smallest. This can be achieved with the help of reverse inorder traversal. Perform these two traversals simultaneously. Sum up the corresponding node’s value from both the BSTs at a particular instance of traversals. If sum == x, then increment count. If x > sum, then move to the inorder successor of the current node of BST 1, else move to the inorder predecessor of the current node of BST 2. Perform these operations until either of the two traversals gets completed.

## C++

 `// C++ implementation to count pairs from two ` `// BSTs whose sum is equal to a given  value x ` `#include ` `using` `namespace` `std; ` ` `  `// structure of a node of BST ` `struct` `Node { ` `    ``int` `data; ` `    ``Node* left, *right; ` `}; ` ` `  `// function to create and return a node of BST ` `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; ` `} ` ` `  `// function to count pairs from two BSTs ` `// whose sum is equal to a given value x ` `int` `countPairs(Node* root1, Node* root2, ``int` `x) ` `{ ` `    ``// if either of the tree is empty ` `    ``if` `(root1 == NULL || root2 == NULL) ` `        ``return` `0; ` ` `  `    ``// stack 'st1' used for the inorder ` `    ``// traversal of BST 1 ` `    ``// stack 'st2' used for the reverse ` `    ``// inorder traversal of BST 2 ` `    ``stack st1, st2; ` `    ``Node* top1, *top2; ` ` `  `    ``int` `count = 0; ` ` `  `    ``// the loop will break when either of two ` `    ``// traversals gets completed ` `    ``while` `(1) { ` ` `  `        ``// to find next node in inorder ` `        ``// traversal of BST 1 ` `        ``while` `(root1 != NULL) { ` `            ``st1.push(root1); ` `            ``root1 = root1->left; ` `        ``} ` ` `  `        ``// to find next node in reverse ` `        ``// inorder traversal of BST 2 ` `        ``while` `(root2 != NULL) { ` `            ``st2.push(root2); ` `            ``root2 = root2->right; ` `        ``} ` ` `  `        ``// if either gets empty then corresponding ` `        ``// tree traversal is completed ` `        ``if` `(st1.empty() || st2.empty()) ` `            ``break``; ` ` `  `        ``top1 = st1.top(); ` `        ``top2 = st2.top(); ` ` `  `        ``// if the sum of the node's is equal to 'x' ` `        ``if` `((top1->data + top2->data) == x) { ` `            ``// increment count ` `            ``count++; ` ` `  `            ``// pop nodes from the respective stacks ` `            ``st1.pop(); ` `            ``st2.pop(); ` ` `  `            ``// insert next possible node in the ` `            ``// respective stacks ` `            ``root1 = top1->right; ` `            ``root2 = top2->left; ` `        ``} ` ` `  `        ``// move to next possible node in the ` `        ``// inoder traversal of BST 1 ` `        ``else` `if` `((top1->data + top2->data) < x) { ` `            ``st1.pop(); ` `            ``root1 = top1->right; ` `        ``} ` ` `  `        ``// move to next possible node in the ` `        ``// reverse inoder traversal of BST 2 ` `        ``else` `{ ` `            ``st2.pop(); ` `            ``root2 = top2->left; ` `        ``} ` `    ``} ` ` `  `    ``// required count of pairs ` `    ``return` `count; ` `} ` ` `  `// Driver program to test above ` `int` `main() ` `{ ` `    ``// formation of BST 1 ` `    ``Node* root1 = getNode(5); ``/*             5        */` `    ``root1->left = getNode(3); ``/*           /   \      */` `    ``root1->right = getNode(7); ``/*         3     7     */` `    ``root1->left->left = getNode(2); ``/*    / \   / \    */` `    ``root1->left->right = getNode(4); ``/*  2  4  6  8    */` `    ``root1->right->left = getNode(6); ` `    ``root1->right->right = getNode(8); ` ` `  `    ``// formation of BST 2 ` `    ``Node* root2 = getNode(10); ``/*           10         */` `    ``root2->left = getNode(6); ``/*           /   \        */` `    ``root2->right = getNode(15); ``/*        6     15      */` `    ``root2->left->left = getNode(3); ``/*    / \   /  \     */` `    ``root2->left->right = getNode(8); ``/*  3  8  11  18    */` `    ``root2->right->left = getNode(11); ` `    ``root2->right->right = getNode(18); ` ` `  `    ``int` `x = 16; ` `    ``cout << ``"Pairs = "` `         ``<< countPairs(root1, root2, x); ` ` `  `    ``return` `0; ` `} `

## Java

 `// Java implementation to count pairs from two ` `// BSTs whose sum is equal to a given  value x ` `import` `java.util.Stack; ` `public` `class` `GFG { ` ` `  `    ``// structure of a node of BST ` `    ``static` `class` `Node { ` `        ``int` `data; ` `        ``Node left, right; ` `         `  `        ``// constructor ` `        ``public` `Node(``int` `data) { ` `            ``this``.data = data; ` `            ``left = ``null``; ` `            ``right = ``null``; ` `        ``} ` `    ``} ` `     `  `    ``static` `Node root1; ` `    ``static` `Node root2; ` `    ``// function to count pairs from two BSTs ` `    ``// whose sum is equal to a given value x ` `    ``static` `int` `countPairs(Node root1, Node root2, ` `                                           ``int` `x) ` `    ``{ ` `        ``// if either of the tree is empty ` `        ``if` `(root1 == ``null` `|| root2 == ``null``) ` `            ``return` `0``; ` `      `  `        ``// stack 'st1' used for the inorder ` `        ``// traversal of BST 1 ` `        ``// stack 'st2' used for the reverse ` `        ``// inorder traversal of BST 2 ` `        ``//stack st1, st2; ` `        ``Stack st1 = ``new` `Stack<>(); ` `        ``Stack st2 = ``new` `Stack<>(); ` `        ``Node top1, top2; ` `      `  `        ``int` `count = ``0``; ` `      `  `        ``// the loop will break when either of two ` `        ``// traversals gets completed ` `        ``while` `(``true``) { ` `      `  `            ``// to find next node in inorder ` `            ``// traversal of BST 1 ` `            ``while` `(root1 != ``null``) { ` `                ``st1.push(root1); ` `                ``root1 = root1.left; ` `            ``} ` `      `  `            ``// to find next node in reverse ` `            ``// inorder traversal of BST 2 ` `            ``while` `(root2 != ``null``) { ` `                ``st2.push(root2); ` `                ``root2 = root2.right; ` `            ``} ` `      `  `            ``// if either gets empty then corresponding ` `            ``// tree traversal is completed ` `            ``if` `(st1.empty() || st2.empty()) ` `                ``break``; ` `      `  `            ``top1 = st1.peek(); ` `            ``top2 = st2.peek(); ` `      `  `            ``// if the sum of the node's is equal to 'x' ` `            ``if` `((top1.data + top2.data) == x) { ` `                ``// increment count ` `                ``count++; ` `      `  `                ``// pop nodes from the respective stacks ` `                ``st1.pop(); ` `                ``st2.pop(); ` `      `  `                ``// insert next possible node in the ` `                ``// respective stacks ` `                ``root1 = top1.right; ` `                ``root2 = top2.left; ` `            ``} ` `      `  `            ``// move to next possible node in the ` `            ``// inoder traversal of BST 1 ` `            ``else` `if` `((top1.data + top2.data) < x) { ` `                ``st1.pop(); ` `                ``root1 = top1.right; ` `            ``} ` `      `  `            ``// move to next possible node in the ` `            ``// reverse inoder traversal of BST 2 ` `            ``else` `{ ` `                ``st2.pop(); ` `                ``root2 = top2.left; ` `            ``} ` `        ``} ` `      `  `        ``// required count of pairs ` `        ``return` `count; ` `    ``} ` `      `  `    ``// Driver program to test above ` `    ``public` `static` `void` `main(String args[]) ` `    ``{ ` `        ``// formation of BST 1 ` `        ``root1 = ``new` `Node(``5``);       ``/*             5        */` `        ``root1.left = ``new` `Node(``3``); ``/*           /   \      */` `        ``root1.right = ``new` `Node(``7``); ``/*         3     7     */` `        ``root1.left.left = ``new` `Node(``2``); ``/*    / \   / \    */` `        ``root1.left.right = ``new` `Node(``4``); ``/*  2   4 6   8    */` `        ``root1.right.left = ``new` `Node(``6``); ` `        ``root1.right.right = ``new` `Node(``8``); ` `      `  `        ``// formation of BST 2 ` `        ``root2 = ``new` `Node(``10``);        ``/*           10         */` `        ``root2.left = ``new` `Node(``6``); ``/*           /   \        */` `        ``root2.right = ``new` `Node(``15``); ``/*        6     15      */` `        ``root2.left.left = ``new` `Node(``3``); ``/*    / \   /  \     */` `        ``root2.left.right = ``new` `Node(``8``); ``/*  3  8  11  18    */` `        ``root2.right.left = ``new` `Node(``11``); ` `        ``root2.right.right = ``new` `Node(``18``); ` `      `  `        ``int` `x = ``16``; ` `        ``System.out.println(``"Pairs = "` `             ``+ countPairs(root1, root2, x)); ` `    ``} ` `} ` `// This code is contributed by Sumit Ghosh `

## C#

 `using` `System; ` `using` `System.Collections.Generic; ` ` `  `// C# implementation to count pairs from two  ` `// BSTs whose sum is equal to a given  value x  ` `public` `class` `GFG ` `{ ` ` `  `    ``// structure of a node of BST  ` `    ``public` `class` `Node ` `    ``{ ` `        ``public` `int` `data; ` `        ``public` `Node left, right; ` ` `  `        ``// constructor  ` `        ``public` `Node(``int` `data) ` `        ``{ ` `            ``this``.data = data; ` `            ``left = ``null``; ` `            ``right = ``null``; ` `        ``} ` `    ``} ` ` `  `    ``public` `static` `Node root1; ` `    ``public` `static` `Node root2; ` `    ``// function to count pairs from two BSTs  ` `    ``// whose sum is equal to a given value x  ` `    ``public` `static` `int` `countPairs(Node root1, Node root2, ``int` `x) ` `    ``{ ` `        ``// if either of the tree is empty  ` `        ``if` `(root1 == ``null` `|| root2 == ``null``) ` `        ``{ ` `            ``return` `0; ` `        ``} ` ` `  `        ``// stack 'st1' used for the inorder  ` `        ``// traversal of BST 1  ` `        ``// stack 'st2' used for the reverse  ` `        ``// inorder traversal of BST 2  ` `        ``//stack st1, st2;  ` `        ``Stack st1 = ``new` `Stack(); ` `        ``Stack st2 = ``new` `Stack(); ` `        ``Node top1, top2; ` ` `  `        ``int` `count = 0; ` ` `  `        ``// the loop will break when either of two  ` `        ``// traversals gets completed  ` `        ``while` `(``true``) ` `        ``{ ` ` `  `            ``// to find next node in inorder  ` `            ``// traversal of BST 1  ` `            ``while` `(root1 != ``null``) ` `            ``{ ` `                ``st1.Push(root1); ` `                ``root1 = root1.left; ` `            ``} ` ` `  `            ``// to find next node in reverse  ` `            ``// inorder traversal of BST 2  ` `            ``while` `(root2 != ``null``) ` `            ``{ ` `                ``st2.Push(root2); ` `                ``root2 = root2.right; ` `            ``} ` ` `  `            ``// if either gets empty then corresponding  ` `            ``// tree traversal is completed  ` `            ``if` `(st1.Count == 0 || st2.Count == 0) ` `            ``{ ` `                ``break``; ` `            ``} ` ` `  `            ``top1 = st1.Peek(); ` `            ``top2 = st2.Peek(); ` ` `  `            ``// if the sum of the node's is equal to 'x'  ` `            ``if` `((top1.data + top2.data) == x) ` `            ``{ ` `                ``// increment count  ` `                ``count++; ` ` `  `                ``// pop nodes from the respective stacks  ` `                ``st1.Pop(); ` `                ``st2.Pop(); ` ` `  `                ``// insert next possible node in the  ` `                ``// respective stacks  ` `                ``root1 = top1.right; ` `                ``root2 = top2.left; ` `            ``} ` ` `  `            ``// move to next possible node in the  ` `            ``// inoder traversal of BST 1  ` `            ``else` `if` `((top1.data + top2.data) < x) ` `            ``{ ` `                ``st1.Pop(); ` `                ``root1 = top1.right; ` `            ``} ` ` `  `            ``// move to next possible node in the  ` `            ``// reverse inoder traversal of BST 2  ` `            ``else` `            ``{ ` `                ``st2.Pop(); ` `                ``root2 = top2.left; ` `            ``} ` `        ``} ` ` `  `        ``// required count of pairs  ` `        ``return` `count; ` `    ``} ` ` `  `    ``// Driver program to test above  ` `    ``public` `static` `void` `Main(``string``[] args) ` `    ``{ ` `        ``// formation of BST 1  ` `        ``root1 = ``new` `Node(5); ``//             5 ` `        ``root1.left = ``new` `Node(3); ``//           /   \ ` `        ``root1.right = ``new` `Node(7); ``//         3     7 ` `        ``root1.left.left = ``new` `Node(2); ``//    / \   / \ ` `        ``root1.left.right = ``new` `Node(4); ``//  2   4 6   8 ` `        ``root1.right.left = ``new` `Node(6); ` `        ``root1.right.right = ``new` `Node(8); ` ` `  `        ``// formation of BST 2  ` `        ``root2 = ``new` `Node(10); ``//           10 ` `        ``root2.left = ``new` `Node(6); ``//           /   \ ` `        ``root2.right = ``new` `Node(15); ``//        6     15 ` `        ``root2.left.left = ``new` `Node(3); ``//    / \   /  \ ` `        ``root2.left.right = ``new` `Node(8); ``//  3  8  11  18 ` `        ``root2.right.left = ``new` `Node(11); ` `        ``root2.right.right = ``new` `Node(18); ` ` `  `        ``int` `x = 16; ` `        ``Console.WriteLine(``"Pairs = "` `+ countPairs(root1, root2, x)); ` `    ``} ` `} ` ` `  `  ``// This code is contributed by Shrikant13 `

Output:

```Pairs = 3
```

Time Complexity: O(n1 + n2)
Auxiliary Space: O(n1 + n2)

This article is contributed by Ayush Jauhari. 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.