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

Problem Statement:

Given two BSTs with x1 and x2 distinct nodes and asked to find values of two nodes whose sum is exactly equivalent to value x

BST 1:
    3
   / \
  1   4
 /     \
0       2
BST 2:
    7
   / \
  5   10
 /     /\
4     8  12
Target value x = 10
Output:
3
The pairs are:
(3,7), (10,0), and (2,8)

Likewise try to implement code for this approach

Approach 1:

To identify pairs in two Binary Search Trees (BSTs), you can perform the following steps without plagiarism concerns:

For each node value 'a' in BST 1, conduct a search to find the value '(x - a)' in BST 2.
If the desired value is discovered, increase the count to keep track of the pairs.

Java Implementation of the above mentioned approach

import java.util.*;
// Definition of a TreeNode, representing a node in a Binary Search Tree (BST).
class TreeNode {
    int value;
    TreeNode left, right;
    TreeNode(int x) {
        value = x;
        left = right = null;
    }
}
public class PairCounter {
    // Function to insert a node in a Binary Search Tree (BST).
    static TreeNode insert(TreeNode root, int value) {
        if (root == null)
            return new TreeNode(value);
        if (value < root.value)
            root.left = insert(root.left, value);
        else if (value > root.value)
            root.right = insert(root.right, value);
        return root;
    }
    // Function to count pairs with a sum equal to a target sum in two BSTs.
    static int countPairsWithSum(TreeNode root1, TreeNode root2, int targetSum) {
        // Create a set to store values from the second BST.
        Set<Integer> valueSet = new HashSet<>();      
        // Create a stack for iterative traversal of the second BST.
        Stack<TreeNode> stack = new Stack<>();       
        TreeNode current = root2;
        // Traverse the second BST and store values in the set.
        while (current != null || !stack.empty()) {
            while (current != null) {
                stack.push(current);
                current = current.left;
            }
            current = stack.pop();
            valueSet.add(current.value);
            current = current.right;
        }
        // Initialize a count to keep track of pairs with the target sum.
        int count = 0;
        current = root1;
        // Traverse the first BST and search for values that form pairs with the target sum.
        while (current != null || !stack.empty()) {
            while (current != null) {
                stack.push(current);
                current = current.left;
            }
            current = stack.pop();           
            // If (targetSum - current.value) is in the set, increment the count.
            if (valueSet.contains(targetSum - current.value))
                count++;      
            current = current.right;
        }
        return count;
    }
    public static void main(String[] args) {
        // Create two empty BSTs, root1 and root2.
        TreeNode root1 = null, root2 = null;     
        // Insert values into the first BST (root1).
        root1 = insert(root1, 5);
        root1 = insert(root1, 3);
        root1 = insert(root1, 7);
        root1 = insert(root1, 2);
        root1 = insert(root1, 4);
        root1 = insert(root1, 6);
        root1 = insert(root1, 8);
        // Insert values into the second BST (root2).
        root2 = insert(root2, 10);
        root2 = insert(root2, 6);
        root2 = insert(root2, 15);
        root2 = insert(root2, 3);
        root2 = insert(root2, 8);
        root2 = insert(root2, 11);
        root2 = insert(root2, 18);
        // Set the target sum for finding pairs.
        int targetSum = 16;
        // Count pairs with the specified target sum in the two BSTs.
        int count = countPairsWithSum(root1, root2, targetSum);
        // Print the count of pairs with the target sum.
        System.out.println("Count of pairs with sum " + targetSum + " is " + count);
    }
}

Output:

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

Explanation:

insert Method:

The insert method is used to insert a new node with a given value into a BST. It ensures that the nodes are added in the appropriate place based on their values.

countPairsWithSum Method:

The countPairsWithSum method takes two BSTs (root1 and root2) and a target sum (targetSum) as input.
It uses a set (valueSet) to store the values from the second BST (root2) and a stack (stack) for iterative traversal.
The method traverses root2 and populates valueSet with its values, preparing it for later pair counting.
It then initializes a count to keep track of pairs and traverses root1 to search for values that, when combined with values from valueSet, form pairs with the target sum.
If a pair is found, the count is incremented.

Approach 2:

Traverse the first BST (BST 1) from its smallest value to the largest value. This can be accomplished through iterative inorder traversal, which visits nodes in ascending order.
Simultaneously, traverse the second BST (BST 2) from its largest value to the smallest value. This is achieved through a reverse inorder traversal, visiting nodes in descending order.
While traversing both BSTs, sum up the values of the corresponding nodes from BST 1 and BST 2 at a given point during the traversal.
If the sum of these node values equals the target value 'x,' increment a count to keep track of the pairs.
If the sum is less than 'x,' move to the inorder successor of the current node in BST 1 to potentially increase the sum.
If the sum is greater than 'x,' move to the inorder predecessor of the current node in BST 2 to potentially decrease the sum.
Continue these operations until one of the two traversals completes.

This method efficiently finds pairs of nodes in the two BSTs that sum up to the target value 'x' and is a common approach for solving this problem.

Algorithm:

Initialize count to 0.
Initialize two empty stacks, stack1 for BST1 and stack2 for BST2.
Start traversing BST1 in ascending order and BST2 in descending order simultaneously.
- Initialize curr1 to the leftmost node in BST1 (smallest value node).
- Initialize curr2 to the rightmost node in BST2 (largest value node).
While both curr1 and curr2 are not null or while stack1 and stack2 are not empty, do the following:
1. Traverse BST1 in ascending order (inorder) and push nodes onto stack1:
  - While curr1 is not null, push curr1 onto stack1, and update curr1 to curr1.left.
2. Traverse BST2 in descending order (reverse inorder) and push nodes onto stack2:
  - While curr2 is not null, push curr2 onto stack2, and update curr2 to curr2.right.
Within the loop:
1. If stack1 is empty or stack2 is empty, break the loop as one of the traversals is complete.
2. Pop the top nodes from stack1 and stack2 (top1 and top2).
3. Calculate the sum as sum = top1.value + top2.value.
4. If sum is equal to 'x':
  - Increment the count by 1.
5. If sum is less than 'x':
  - Move to the inorder successor of top1 in BST1:
  - Set curr1 to top1.right.
6. If sum is greater than 'x':
  - Move to the inorder predecessor of top2 in BST2:
  - Set curr2 to top2.left.
Return the count as the total number of pairs with a sum equal to 'x' in the two BSTs.
End of the algorithm.

Java Implementation of the above mentioned approach

import java.util.Stack;

public class PairCounter {

    // Definition of TreeNode class for a binary tree node.
    static class TreeNode {
        int value;
        TreeNode left, right;
        public TreeNode(int value) {
            this.value = value;
            left = null;
            right = null;
        }
    }

    // Initialize two binary trees.
    static TreeNode tree1;
    static TreeNode tree2;
    // Function to count pairs of nodes from two binary trees with a sum equal to a given target.
    static int countPairsWithSum(TreeNode tree1, TreeNode tree2, int targetSum) {
        // If either of the binary trees is empty, there can be no pairs.
        if (tree1 == null || tree2 == null)
            return 0;
        // Initialize two stacks for inorder traversal of both binary trees.
        Stack<TreeNode> stack1 = new Stack<>();
        Stack<TreeNode> stack2 = new Stack<>();
        TreeNode top1, top2;
        int count = 0;
        // The loop continues until either of the traversals completes.
        while (true) {
            // Inorder traversal of tree1.
            while (tree1 != null) {
                stack1.push(tree1);
                tree1 = tree1.left;
            }
            // Reverse inorder traversal of tree2.
            while (tree2 != null) {
 stack2.push(tree2);
                tree2 = tree2.right;
            }
            // If either of the stacks becomes empty, the traversal is complete.
            if (stack1.empty() || stack2.empty())
                break;
            // Peek the top nodes of both stacks.
            top1 = stack1.peek();
            top2 = stack2.peek();
            // Calculate the sum of values of the current nodes.
            int currentSum = top1.value + top2.value;
            // If the sum is equal to the target, increment the count and move to the next nodes.
            if (currentSum == targetSum) {
                count++;
                stack1.pop();
                stack2.pop();
                tree1 = top1.right;
                tree2 = top2.left;
            } 
// If the sum is less than the target, move to the next node in tree1.
            else if (currentSum < targetSum) {
                stack1.pop();
                tree1 = top1.right;
            } 
            // If the sum is greater than the target, move to the next node in tree2.
            else {
                stack2.pop();
                tree2 = top2.left;
            }
        }
        // Return the count of pairs with the specified target sum.
        return count;
    }
    public static void main(String args[]) {
        // Create the first binary tree (tree1).
        tree1 = new TreeNode(5);
        tree1.left = new TreeNode(3);
        tree1.right = new TreeNode(7);
        tree1.left.left = new TreeNode(2);
        tree1.left.right = new TreeNode(4);
        tree1.right.left = new TreeNode(6);
        tree1.right.right = new TreeNode(8);
        // Create the second binary tree (tree2).
        tree2 = new TreeNode(10);
        tree2.left = new TreeNode(6);
        tree2.right = new TreeNode(15);
        tree2.left.left = new TreeNode(3);
        tree2.left.right = new TreeNode(8);
        tree2.right.left = new TreeNode(11);
        tree2.right.right = new TreeNode(18);

        // Define the target sum.
        int targetSum = 16;
        // Call the countPairsWithSum function to count pairs with the target sum and print the result.
        System.out.println("Count of pairs with sum " + targetSum + " is " + countPairsWithSum(tree1, tree2, targetSum));
    }
}

Output:

Time Complexity:O(n1+n2)

Space Complexity:O(h1+h2)

Approach 3:

Utilize a recursive strategy to address this problem by traversing BST1, and for each node encountered, calculate the difference (x - root1.data) within BST2, subsequently increasing a counter to keep track of the occurrences.

Java Implementation of the above mentioned approach

public class TwoBSTPairCount {
    // Definition of a TreeNode class to represent nodes in a binary search tree.
    static class TreeNode {
        int value;            // Value stored in the node.
        TreeNode left, right; // References to the left and right child nodes.
        public TreeNode(int value) {
            this.value = value;
            left = null;
            right = null;
        }
    }
    static TreeNode root1; // Root node of the first binary search tree (BST).
    static TreeNode root2; // Root node of the second binary search tree (BST).
    public static int pairCount = 0; // Counter to keep track of the number of pairs found.
    // Function to traverse both BSTs and count pairs whose sum is equal to the given 'sum'.
    public static void traverseAndCountPairs(TreeNode node1, TreeNode node2, int sum) {
        if (node1 == null || node2 == null) {
            return; // Base case: If either of the trees is empty, return.
        }
        // Recursively traverse the left and right subtrees of the first BST.
        traverseAndCountPairs(node1.left, node2, sum);
        traverseAndCountPairs(node1.right, node2, sum);
        int diff = sum - node1.value; // Calculate the difference needed to find a pair.
        findPairs(node2, diff); // Search for pairs in the second BST using the difference.
    }
    // Function to find pairs in the second BST that match the given difference.
    private static void findPairs(TreeNode node2, int diff) {
        if (node2 == null) {
            return; // Base case: If the second BST is empty, return.
        }
        // Recursively search for pairs in the second BST, based on the difference.
        if (diff > node2.value) {
            findPairs(node2.right, diff); // Explore the right subtree if diff is greater.
        } else {
            findPairs(node2.left, diff); // Explore the left subtree if diff is less or equal.
        }
        // If a pair is found (nodes with values that sum up to the difference), increment the pairCount.
        if (node2.value == diff) {
            pairCount++;
        }
    }
    // Function to count pairs whose sum is equal to the given 'sum'.
    public static int countPairs(TreeNode root1, TreeNode root2, int sum) {
        traverseAndCountPairs(root1, root2, sum); // Initiate the traversal and counting process.
        return pairCount; // Return the total count of pairs.
    }
    public static void main(String args[]) {
        // Create the first binary search tree (BST).
        root1 = new TreeNode(5);
        root1.left = new TreeNode(3);
        root1.right = new TreeNode(7);
        root1.left.left = new TreeNode(2);
        root1.left.right = new TreeNode(4);
        root1.right.left = new TreeNode(6);
        root1.right.right = new TreeNode(8);
        // Create the second binary search tree (BST).
        root2 = new TreeNode(10);
        root2.left = new TreeNode(6);
        root2.right = new TreeNode(15);
        root2.left.left = new TreeNode(3);
        root2.left.right = new TreeNode(8);
        root2.right.left = new TreeNode(11);
        root2.right.right = new TreeNode(18);
        int sum = 16;
        System.out.println("Pairs = " + countPairs(root1, root2, sum)); // Print the count of pairs with the given sum.
    }
}

Output:

Time Complexity: The code's time complexity is O(n1 * n2) since it involves iterating through each node in BST1 and, for each of those nodes, traversing BST2 to determine if a matching pair with the given difference exists.

Auxiliary Space: The auxiliary space complexity is O(h1 + h2), where h1 represents the height of BST1 and h2 represents the height of BST2. This space is required for the function call stack during the recursive traversal, which increases with the height of the respective trees.

Approach 4: Making use of concept of BST iterator

Two classes InorderSuccessorIterator and InorderPredecessorIterator which serves for inorder and reverseinorder behaviour

Each class will include three functions:

hasNext: Returns true while the traversal is ongoing.

next: Advances the pointer to the next node.

peek: Provides the current node in the ongoing traversal.

After establishing two instances of these classes, execute the iterator while both classes have the next node. Calculate the sum during each iteration. If the sum equals x, proceed by advancing the next pointer of both iterator1 and iterator2. In case the sum is greater than x, increment the next pointer of iterator2; otherwise, increment the next pointer of iterator1 when the sum is less than x.

Java Implementation of the above mentioned approach

import java.util.Stack;
// Definition of a TreeNode, representing a node in a Binary Search Tree (BST).
class TreeNode {
    int value;
    TreeNode left, right;
    // Constructor to initialize a TreeNode with a given value.
    public TreeNode(int value) {
        this.value = value;
        this.left = null;
        this.right = null;
    }
}
// Iterator for traversing the in-order successor of a BST.
class InorderSuccessorIterator {
    Stack<TreeNode> stack = new Stack<>();
    TreeNode root;
    boolean hasPeeked = false;
    // Constructor to initialize the iterator with a BST root.
    public InorderSuccessorIterator(TreeNode root) {
        this.root = root;
    }
    // Check if there is a next node in the in-order successor traversal.
    public boolean hasNext() {
        if (!stack.isEmpty() || root != null)
            return true;
        return false;
    }
    // Get the next node in the in-order successor traversal without moving the iterator.
    public TreeNode peek() {
        if (!hasNext())
            return null;
        while (root != null) {
            stack.push(root);
            root = root.left;
            hasPeeked = true;
        }
        return stack.peek();
    }
  // Move the iterator to the next node in the in-order successor traversal and return its value.
    public int next() {
        if (!hasNext())
            return -1;
        if (!hasPeeked)
            peek();
        hasPeeked = false;
        root = stack.pop();
        TreeNode temp = root;
        root = root.right;
        return temp.value;
    }
}
// Iterator for traversing the in-order predecessor of a BST.
class InorderPredecessorIterator {
    Stack<TreeNode> stack = new Stack<>();
    TreeNode root;
    boolean hasPeeked = false;
    // Constructor to initialize the iterator with a BST root.
    public InorderPredecessorIterator(TreeNode root) {
        this.root = root;
    }
    // Check if there is a next node in the in-order predecessor traversal.
    public boolean hasNext() {
        if (!stack.isEmpty() || root != null)
            return true;
        return false;
    }
    // Get the next node in the in-order predecessor traversal without moving the iterator.
    public TreeNode peek() {
        if (!hasNext())
            return null;
        while (root != null) {
            stack.push(root);
            root = root.right;
            hasPeeked = true;
        }
        return stack.peek();
    }
    // Move the iterator to the next node in the in-order predecessor traversal and return its value.
    public int next() {
        if (!hasNext())
            return -1;
        if (!hasPeeked)
            peek();
        hasPeeked = false;
        root = stack.pop();
        TreeNode temp = root;
        root = root.left;
        return temp.value;
    }
}

// Class to count pairs with a given sum in two BSTs.
class PairCounter {
    // Function to count pairs with a sum equal to a target sum in two BSTs.
    public static int countPairs(TreeNode node1, TreeNode node2, int targetSum) {
        InorderSuccessorIterator iterator1 = new InorderSuccessorIterator(node1);
        InorderPredecessorIterator iterator2 = new InorderPredecessorIterator(node2);
        int count = 0;
        // Iterate through the iterators while there are nodes in both BSTs.
        while (iterator1.hasNext() && iterator2.hasNext()) {
            TreeNode current1 = iterator1.peek();
            TreeNode current2 = iterator2.peek();
            int sum = current1.value + current2.value;

            // Check the sum and update the iterators accordingly.
            if (sum == targetSum) {
                count++;
                iterator1.next();
                iterator2.next();
            } else if (sum > targetSum) {
                iterator2.next();
            } else {
                iterator1.next();
            }
        }
        return count;
    }
    // Main method to test the pair counting functionality.
    public static void main(String args[]) {
        TreeNode root1, root2;

        // Formation of BST 1
        root1 = new TreeNode(5);
        root1.left = new TreeNode(3);
        root1.right = new TreeNode(7);
        root1.left.left = new TreeNode(2);
        root1.left.right = new TreeNode(4);
        root1.right.left = new TreeNode(6);
        root1.right.right = new TreeNode(8);
        // Formation of BST 2
        root2 = new TreeNode(10);
        root2.left = new TreeNode(6);
        root2.right = new TreeNode(15);
        root2.left.left = new TreeNode(3);
        root2.left.right = new TreeNode(8);
        root2.right.left = new TreeNode(11);
        root2.right.right = new TreeNode(18);
        // Set the target sum for finding pairs.
        int targetSum = 16;
        // Count pairs with the specified target sum in the two BSTs.
        int count = countPairs(root1, root2, targetSum);
        // Print the count of pairs with the target sum.
        System.out.println("Count of pairs with sum " + targetSum + " is " + count);
    }
}

Output: