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

Last Updated : 11 Oct, 2025

Given the roots of two Binary Search Trees, root1 and root2, and an integer x, count all pairs of nodes whose sum is equal to x.
Examples: 

Input : x = 6

100

Output: 2
Explanation: The pairs are: (2, 4) and (1, 5) whose sum is equal to x.

Try It Yourself
redirect icon

Table of Content

[Naive Approach] By Trying all Possible Pairs - O(n1 * n2) Time and O(h1 + h2) Space

The idea is to traverse the first BST. For each node, search for the value (x - node) in the second BST. If the value exists, increment the count.

C++ 
//Driver Code Starts
#include <iostream>
using namespace std;

 // Node structure
class Node {
public:
    int data;
    Node* left, *right;
    Node (int x) {
        data = x;
        left = nullptr;
        right = nullptr;
    }
};
//Driver Code Ends


// Search for (x-node value) in second bst
bool findVal(Node* root, int x) {
    
    if (root == nullptr) return false;
    
    if (root->data == x) return true;
    else if (root->data < x)
        return findVal(root->right, x);
    else 
        return findVal(root->left, x);
}

// Function to count pairs with sum equal to x
int countPairs(Node* root1, Node* root2, int x) {

    if (root1 == nullptr) return 0;
    
    int ans = 0;
    
    // If pair (root1.data, x-root1.data) exists,
    // then increment the ans.
    if (findVal(root2, x-root1->data))
        ans++;
    
    // Recursively check for left and right subtree.    
    ans += countPairs(root1->left, root2, x);
    ans += countPairs(root1->right, root2, x);
    
    return ans;
}


//Driver Code Starts
int main() {
    
    // BST1
    //    2
    //  /  \
    // 1   3
    Node* root1 = new Node(2);
    root1->left = new Node(1);
    root1->right = new Node(3);
    
    // BST2
    //    5
    //  /  \
    // 4   6
    Node* root2 = new Node(5);
    root2->left = new Node(4);
    root2->right = new Node(6);
    
    int x = 6;
    cout << countPairs(root1, root2, x);

    return 0;
}
//Driver Code Ends
Java 
//Driver Code Starts

// Node structure
class Node {
    int data;
    Node left, right;

    Node(int x) {
        data = x;
        left = null;
        right = null;
    }
}

class GfG {
//Driver Code Ends


    // Search for (x-node value) in second bst
    static boolean findVal(Node root, int x) {
        if (root == null) return false;

        if (root.data == x) return true;
        else if (root.data < x)
            return findVal(root.right, x);
        else
            return findVal(root.left, x);
    }

    // Function to count pairs with sum equal to x
    static int countPairs(Node root1, Node root2, int x) {
        if (root1 == null) return 0;
        
        int ans = 0;
        
        // If pair (root1.data, x-root1.data) exists,
        // then increment the ans.
        if (findVal(root2, x - root1.data))
            ans++;
        
        // Recursively check for left and right subtree.
        ans += countPairs(root1.left, root2, x);
        ans += countPairs(root1.right, root2, x);
        
        return ans;
    }


//Driver Code Starts
    public static void main(String[] args) {

        // BST1
        //    2
        //  /  \
        // 1   3
        Node root1 = new Node(2);
        root1.left = new Node(1);
        root1.right = new Node(3);

        // BST2
        //    5
        //  /  \
        // 4   6
        Node root2 = new Node(5);
        root2.left = new Node(4);
        root2.right = new Node(6);

        int x = 6;
        System.out.println(countPairs(root1, root2, x));
    }
}

//Driver Code Ends
Python 
#Driver Code Starts

#  Node structure
class Node:
    def __init__(self, x):
        self.data = x
        self.left = None
        self.right = None
#Driver Code Ends


#  Search for (x-node value) in second bst
def findVal(root, x):
    if root is None:
        return False

    if root.data == x:
        return True
    elif root.data < x:
        return findVal(root.right, x)
    else:
        return findVal(root.left, x)

# Function to count pairs with sum equal to x
def countPairs(root1, root2, x):
    if root1 is None:
        return 0
    
    ans = 0
    
    # If pair (root1.data, x-root1.data) exists,
    # then increment the ans.
    if findVal(root2, x - root1.data):
        ans += 1
    
    # Recursively check for left and right subtree.
    ans += countPairs(root1.left, root2, x)
    ans += countPairs(root1.right, root2, x)
    
    return ans


#Driver Code Starts
if __name__ == "__main__":
    
    # BST1
    #    2
    #  /  \
    # 1   3
    root1 = Node(2)
    root1.left = Node(1)
    root1.right = Node(3)

    # BST2
    #    5
    #  /  \
    # 4   6
    root2 = Node(5)
    root2.left = Node(4)
    root2.right = Node(6)

    x = 6
    print(countPairs(root1, root2, x))

#Driver Code Ends
C# 
//Driver Code Starts
using System;

// Node structure
class Node {
    public int data;
    public Node left, right;

    public Node(int x) {
        data = x;
        left = null;
        right = null;
    }
}

class GfG {
//Driver Code Ends


// Search for (x-node value) in second bst
    static bool findVal(Node root, int x) {
        if (root == null) return false;

        if (root.data == x) return true;
        else if (root.data < x)
            return findVal(root.right, x);
        else
            return findVal(root.left, x);
    }

    // Function to count pairs with sum equal to x
    static int countPairs(Node root1, Node root2, int x) {
        if (root1 == null) return 0;
        
        int ans = 0;
        
        // If pair (root1.data, x-root1.data) exists,
        // then increment the ans.
        if (findVal(root2, x - root1.data))
            ans++;
        
        // Recursively check for left and 
      	// right subtree.
        ans += countPairs(root1.left, root2, x);
        ans += countPairs(root1.right, root2, x);
        
        return ans;
    }


//Driver Code Starts
    static void Main(string[] args) {
        
        // BST1
        //    2
        //  /  \
        // 1   3
        Node root1 = new Node(2);
        root1.left = new Node(1);
        root1.right = new Node(3);

        // BST2
        //    5
        //  /  \
        // 4   6
        Node root2 = new Node(5);
        root2.left = new Node(4);
        root2.right = new Node(6);

        int x = 6;
        Console.WriteLine(countPairs(root1, root2, x));
    }
}

//Driver Code Ends
JavaScript 
//Driver Code Starts

// Node structure
class Node {
    constructor(x) {
        this.data = x;
        this.left = null;
        this.right = null;
    }
}
//Driver Code Ends


// Search for (x-node value) in second bst
function findVal(root, x) {
    if (root === null) return false;

    if (root.data === x) return true;
    else if (root.data < x)
        return findVal(root.right, x);
    else
        return findVal(root.left, x);
}

// Function to count pairs with 
// sum equal to x
function countPairs(root1, root2, x) {
    if (root1 === null) return 0;
    
    let ans = 0;
    
    // If pair (root1.data, x-root1.data) exists,
    // then increment the ans.
    if (findVal(root2, x - root1.data))
        ans++;
    
    // Recursively check for left and right subtree.
    ans += countPairs(root1.left, root2, x);
    ans += countPairs(root1.right, root2, x);
    
    return ans;
}


//Driver Code Starts

// Driver Code

// BST1
//    2
//  /  \
// 1   3
let root1 = new Node(2);
root1.left = new Node(1);
root1.right = new Node(3);

// BST2
//    5
//  /  \
// 4   6
let root2 = new Node(5);
root2.left = new Node(4);
root2.right = new Node(6);

let x = 6;
console.log(countPairs(root1, root2, x));

//Driver Code Ends

Output
2

[Expected Approach] Two Pointer Technique - O(n1 + n2) Time and O(h1 + h2) Space

Intuition:
If we are given a sorted array and asked to find pairs whose sum is equal to x, we often use the two-pointer technique. One pointer starts from the beginning (smallest value), while the other starts from the end (largest value).
We can apply the same concept to two BSTs.

  • The inorder traversal of a BST gives nodes in sorted ascending order and reverse inorder traversal gives nodes in sorted descending order.
  • So, if we traverse the first BST in inorder (gives the smallest value first) and second BST in reverse inorder (gives the largest value first).
  • It becomes exactly like having two sorted arrays and applying the two-pointer technique to find pairs that sum up to x.

The idea is to use the two-pointer technique with stacks on BSTs. One stack does inorder traversal of the first BST (ascending), the other does reverse inorder traversal of the second BST (descending). At each step, check the sum of the top elements: if it equals x, we found a pair; if greater, move left in the second BST; if smaller, move right in the first BST.

C++ 
//Driver Code Starts
#include <iostream>
#include<stack>
#include<algorithm>
using namespace std;

// Node structure
class Node {
public:
    int data;
    Node* left, *right;
    Node (int x) {
        data = x;
        left = nullptr;
        right = nullptr;
    }
};
//Driver Code Ends


int countPairs(Node* root1, Node* root2, int x) {
    
    if (root1 == nullptr || root2 == nullptr)
        return 0;
    stack<Node*> st1, st2;
    Node* top1, *top2;

    int count = 0;
    while (1) {

        // to find next node in inorder
        // traversal of BST 1
        while (root1 != nullptr) {
            st1.push(root1);
            root1 = root1->left;
        }

        // to find next node in reverse
        // inorder traversal of BST 2
        while (root2 != nullptr) {
            st2.push(root2);
            root2 = root2->right;
        }
        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) {
          
            count++;
            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
        // inorder traversal of BST 1
        else if ((top1->data + top2->data) < x) {
            st1.pop();
            root1 = top1->right;
        }

        // move to next possible node in the
        // reverse inorder traversal of BST 2
        else {
            st2.pop();
            root2 = top2->left;
        }
    }

    return count;
}


//Driver Code Starts

int main() {
    
    // BST1
    //    2
    //  /  \
    // 1   3
    Node* root1 = new Node(2);
    root1->left = new Node(1);
    root1->right = new Node(3);
    
    // BST2
    //    5
    //  /  \
    // 4   6
    Node* root2 = new Node(5);
    root2->left = new Node(4);
    root2->right = new Node(6);
    
    int x = 6;
    cout << countPairs(root1, root2, x);

    return 0;
}
//Driver Code Ends
Java 
//Driver Code Starts
import java.util.Stack;

// Node structure
class Node {
    int data;
    Node left, right;

    Node(int x) {
        data = x;
        left = null;
        right = null;
    }
}

class GfG {
//Driver Code Ends


    static int countPairs(Node root1, Node root2, int x) {
        if (root1 == null || root2 == null)
            return 0;
        Stack<Node> st1 = new Stack<>();
        Stack<Node> st2 = new Stack<>();
        Node top1, top2;

        int count = 0;
        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 (st1.isEmpty() || st2.isEmpty())
                break;

            top1 = st1.peek();
            top2 = st2.peek();

            // if the sum of the node's is equal to 'x'
            if ((top1.data + top2.data) == x) {
                count++;
                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
            // inorder traversal of BST 1
            else if ((top1.data + top2.data) < x) {
                st1.pop();
                root1 = top1.right;
            }

            // move to next possible node in the
            // reverse inorder traversal of BST 2
            else {
                st2.pop();
                root2 = top2.left;
            }
        }
      
        return count;
    }


//Driver Code Starts
    public static void main(String[] args) {
        
        // BST1
        //    2
        //  /  \
        // 1   3
        Node root1 = new Node(2);
        root1.left = new Node(1);
        root1.right = new Node(3);
        
        // BST2
        //    5
        //  /  \
        // 4   6
        Node root2 = new Node(5);
        root2.left = new Node(4);
        root2.right = new Node(6);
        
        int x = 6;
        System.out.println(countPairs(root1, root2, x));
    }
}

//Driver Code Ends
Python 
#Driver Code Starts

#  Node structure
class Node:
    def __init__(self, x):
        self.data = x
        self.left = None
        self.right = None
#Driver Code Ends


def countPairs(root1, root2, x):
    if root1 is None or root2 is None:
        return 0
    st1, st2 = [], []
    count = 0
    
    while True:

        # to find next node in inorder
        # traversal of BST 1
        while root1 is not None:
            st1.append(root1)
            root1 = root1.left

        # to find next node in reverse
        # inorder traversal of BST 2
        while root2 is not None:
            st2.append(root2)
            root2 = root2.right
            
        if not st1 or not st2:
            break

        top1 = st1[-1]
        top2 = st2[-1]

        # if the sum of the node's is equal to 'x'
        if (top1.data + top2.data) == x:
            count += 1
            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
        # inorder traversal of BST 1
        elif (top1.data + top2.data) < x:
            st1.pop()
            root1 = top1.right

        # move to next possible node in the
        # reverse inorder traversal of BST 2
        else:
            st2.pop()
            root2 = top2.left
            
    return count


#Driver Code Starts
if __name__ == "__main__":
    
    # BST1
    #    2
    #  /  \
    # 1   3
    root1 = Node(2)
    root1.left = Node(1)
    root1.right = Node(3)

    # BST2
    #    5
    #  /  \
    # 4   6
    root2 = Node(5)
    root2.left = Node(4)
    root2.right = Node(6)

    x = 6
    print(countPairs(root1, root2, x))

#Driver Code Ends
C# 
//Driver Code Starts
using System;
using System.Collections.Generic;

// Node structure
class Node {
    public int data;
    public Node left, right;

    public Node(int x) {
        data = x;
        left = null;
        right = null;
    }
}

class GfG {
//Driver Code Ends

    
    static int countPairs(Node root1, Node root2, int x) {
        if (root1 == null || root2 == null)
            return 0;
        Stack<Node> st1 = new Stack<Node>();
        Stack<Node> st2 = new Stack<Node>();
        Node top1, top2;

        int count = 0;
        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 (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) {
                count++;
                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
            // inorder traversal of BST 1
            else if ((top1.data + top2.data) < x) {
                st1.Pop();
                root1 = top1.right;
            }

            // move to next possible node in the
            // reverse inorder traversal of BST 2
            else {
                st2.Pop();
                root2 = top2.left;
            }
        }
      
        return count;
    }


//Driver Code Starts
    static void Main(string[] args) {
        
        // BST1
        //    2
        //  /  \
        // 1   3
        Node root1 = new Node(2);
        root1.left = new Node(1);
        root1.right = new Node(3);
        
        // BST2
        //    5
        //  /  \
        // 4   6
        Node root2 = new Node(5);
        root2.left = new Node(4);
        root2.right = new Node(6);
        
        int x = 6;
        Console.WriteLine(countPairs(root1, root2, x));
    }
}

//Driver Code Ends
JavaScript 
//Driver Code Starts
// Node structure
class Node {
    constructor(x)
    {
        this.data = x;
        this.left = null;
        this.right = null;
    }
}
//Driver Code Ends


function countPairs(root1, root2, x)
{
    if (root1 === null || root2 === null)
        return 0;
    let st1 = [], st2 = [];
    let top1, top2;
    let count = 0;
    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 (st1.length === 0 || st2.length === 0)
            break;

        top1 = st1[st1.length - 1];
        top2 = st2[st2.length - 1];

        // if the sum of the node's is equal to 'x'
        if ((top1.data + top2.data) === x) {
            count++;
            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
        // inorder traversal of BST 1
        else if ((top1.data + top2.data) < x) {
            st1.pop();
            root1 = top1.right;
        }

        // move to next possible node in the
        // reverse inorder traversal of BST 2
        else {
            st2.pop();
            root2 = top2.left;
        }
    }

    return count;
}


//Driver Code Starts
// Driver Code

// BST1
//    2
//  /  \
// 1   3
let root1 = new Node(2);
root1.left = new Node(1);
root1.right = new Node(3);

// BST2
//    5
//  /  \
// 4   6
let root2 = new Node(5);
root2.left = new Node(4);
root2.right = new Node(6);

let x = 6;
console.log(countPairs(root1, root2, x));
//Driver Code Ends

Output
2
Comment
Article Tags:
Binary Search Tree
DSA
Traversal

Explore