Skip to content
Related Articles

Related Articles

Improve Article
Find all the pairs with given sum in a BST | Set 2
  • Difficulty Level : Expert
  • Last Updated : 06 Jun, 2021

Given a Binary Search Tree and an integer sum, the task is to find all the pairs from the tree whose sum is equal to the given integer sum
We have discussed a similar problem in this post.

Examples: 

Input:      
              2
            /   \
           1     6
                / \
               5   7
              /
             3
             \
              4
sum = 8
Output:
1 7
2 6
3 5

Input:      
              2
            /   \
           1     3
                  \
                   4
sum = 5
Output:
1 4
2 3

Approach: Traverse the tree in a pre-order manner from both the side, left and right, and store the values of the left and right sides into the ArrayList LeftList and RightList respectively. On reaching the leaf node, take out the left side last value and a right side last value from the respective ArrayLists. There will be three conditions: 

  1. left side value + right side value < sum: Delete the last value of LeftList and make the left side execution to the right side because on moving from the left side to the right side in the tree the value of node increases.
  2. left side value + right side value > sum: Delete the last value of RightList and make the right side execution to the left side because on moving from the right side to the left side in the tree the value of node decreases.
  3. left side value + right side value = sum: Delete the last value of both the lists and make the left side execution to the right side and right side execution to the left side.

Below is the implementation of the above approach:  

C++




// C++ implementation of the
// above approach
#include<bits/stdc++.h>
using namespace std;
struct Node
{
  int data;
  Node *left, *right,
       *root;
 
  Node(int data)
  {
    this -> data = data;
    left = NULL;
    right = NULL;
    root = NULL;
  }
};
 
// Function to add a node
// to the BST
Node* AddNode(Node *root,
              int data)
{
  // If the tree is empty,
  // return a new node
  if (root == NULL)
  {
    root = new Node(data);
    return root;
  }
 
  // Otherwise, recur down
  // the tree
  if (root -> data < data)
    root -> right = AddNode(root -> right,
                            data);
 
  else if (root -> data > data)
    root -> left = AddNode(root -> left,
                           data);
 
  return root;
}
 
// Function to find the
// target pairs
void TargetPair(Node *node,
                int tar)
{
  // LeftList which stores
  // the left side values
  vector<Node*> LeftList;
 
  // RightList which stores
  // the right side values
  vector<Node*> RightList;
 
  // curr_left pointer is used
  // for left side execution and
  // curr_right pointer is used
  // for right side execution
  Node *curr_left = node;
  Node *curr_right = node;
 
  while (curr_left != NULL ||
         curr_right != NULL ||
         LeftList.size() > 0 &&
         RightList.size() > 0)
  {
    // Storing the left side
    // values into LeftList
    // till leaf node not found
    while (curr_left != NULL)
    {
      LeftList.push_back(curr_left);
      curr_left = curr_left -> left;
    }
 
    // Storing the right side
    // values into RightList
    // till leaf node not found
    while (curr_right != NULL)
    {
      RightList.push_back(curr_right);
      curr_right = curr_right -> right;
    }
 
    // Last node of LeftList
    Node *LeftNode =
          LeftList[LeftList.size() - 1];
 
    // Last node of RightList
    Node *RightNode =
          RightList[RightList.size() - 1];
 
    int leftVal = LeftNode -> data;
    int rightVal = RightNode -> data;
 
    // To prevent repetition
    // like 2, 6 and 6, 2
    if (leftVal >= rightVal)
      break;
 
    // Delete the last value of LeftList
    // and make the execution to the
    // right side
    if (leftVal + rightVal < tar)
    {
      LeftList.pop_back();
      curr_left = LeftNode -> right;
    }
 
    // Delete the last value of RightList
    // and make the execution to the left
    // side
    else if (leftVal + rightVal > tar)
    {
      RightList.pop_back();
      curr_right = RightNode -> left;
    }
 
    // (left value + right value) = target
    // then print the left value and right value
    // Delete the last value of left and right list
    // and make the left execution to right side
    // and right side execution to left side
    else
    {
      cout << LeftNode -> data << " " <<
              RightNode -> data << endl;
 
      RightList.pop_back();
      LeftList.pop_back();
      curr_left = LeftNode -> right;
      curr_right = RightNode -> left;
    }
  }
}
 
// Driver code
int main()
{
  Node *root = NULL;
  root  = AddNode(root, 2);
  root = AddNode(root, 6);
  root = AddNode(root, 5);
  root = AddNode(root, 3);
  root = AddNode(root, 4);
  root = AddNode(root, 1);
  root = AddNode(root, 7);
  int sum = 8;
  TargetPair(root, sum);
}
 
// This code is contributed by Rutvik_56

Java




// Java implementation of the approach
import java.util.*;
public class GFG {
 
    // A binary tree node
    public static class Node {
        int data;
        Node left, right, root;
 
        Node(int data)
        {
            this.data = data;
        }
    }
 
    // Function to add a node to the BST
    public static Node AddNode(Node root, int data)
    {
 
        // If the tree is empty, return a new node
        if (root == null) {
            root = new Node(data);
            return root;
        }
 
        // Otherwise, recur down the tree
        if (root.data < data)
            root.right = AddNode(root.right, data);
 
        else if (root.data > data)
            root.left = AddNode(root.left, data);
 
        return root;
    }
 
    // Function to find the target pairs
    public static void TargetPair(Node node, int tar)
    {
 
        // LeftList which stores the left side values
        ArrayList<Node> LeftList = new ArrayList<>();
 
        // RightList which stores the right side values
        ArrayList<Node> RightList = new ArrayList<>();
 
        // curr_left pointer is used for left side execution and
        // curr_right pointer is used for right side execution
        Node curr_left = node;
        Node curr_right = node;
 
        while (curr_left != null || curr_right != null
               || LeftList.size() > 0 && RightList.size() > 0) {
 
            // Storing the left side values into LeftList
            // till leaf node not found
            while (curr_left != null) {
                LeftList.add(curr_left);
                curr_left = curr_left.left;
            }
 
            // Storing the right side values into RightList
            // till leaf node not found
            while (curr_right != null) {
                RightList.add(curr_right);
                curr_right = curr_right.right;
            }
 
            // Last node of LeftList
            Node LeftNode = LeftList.get(LeftList.size() - 1);
 
            // Last node of RightList
            Node RightNode = RightList.get(RightList.size() - 1);
 
            int leftVal = LeftNode.data;
            int rightVal = RightNode.data;
 
            // To prevent repetition like 2, 6 and 6, 2
            if (leftVal >= rightVal)
                break;
 
            // Delete the last value of LeftList and make
            // the execution to the right side
            if (leftVal + rightVal < tar) {
                LeftList.remove(LeftList.size() - 1);
                curr_left = LeftNode.right;
            }
 
            // Delete the last value of RightList and make
            // the execution to the left side
            else if (leftVal + rightVal > tar) {
                RightList.remove(RightList.size() - 1);
                curr_right = RightNode.left;
            }
 
            // (left value + right value) = target
            // then print the left value and right value
            // Delete the last value of left and right list
            // and make the left execution to right side
            // and right side execution to left side
            else {
                System.out.println(LeftNode.data + " " + RightNode.data);
 
                RightList.remove(RightList.size() - 1);
                LeftList.remove(LeftList.size() - 1);
                curr_left = LeftNode.right;
                curr_right = RightNode.left;
            }
        }
    }
 
    // Driver code
    public static void main(String[] b)
    {
 
        Node root = null;
        root = AddNode(root, 2);
        root = AddNode(root, 6);
        root = AddNode(root, 5);
        root = AddNode(root, 3);
        root = AddNode(root, 4);
        root = AddNode(root, 1);
        root = AddNode(root, 7);
        int sum = 8;
        TargetPair(root, sum);
    }
}

Python3




# Python3 implementation of the approach
 
# A binary tree node
class Node:
     
    def __init__(self, key):
         
        self.data = key
        self.left = None
        self.right = None
 
# Function to append a node to the BST
def AddNode(root, data):
     
    # If the tree is empty, return a new node
    if (root == None):
        root = Node(data)
        return root
 
    # Otherwise, recur down the tree
    if (root.data < data):
        root.right = AddNode(root.right, data)
 
    elif (root.data > data):
        root.left = AddNode(root.left, data)
 
    return root
 
# Function to find the target pairs
def TargetPair(node, tar):
  
    # LeftList which stores the left side values
    LeftList = []
 
    # RightList which stores the right side values
    RightList = []
 
    # curr_left pointer is used for left
    # side execution and curr_right pointer
    # is used for right side execution
    curr_left = node
    curr_right = node
 
    while (curr_left != None or
          curr_right != None or
          len(LeftList) > 0 and
          len(RightList) > 0):
               
        # Storing the left side values into
        # LeftList till leaf node not found
        while (curr_left != None):
            LeftList.append(curr_left)
            curr_left = curr_left.left
 
        # Storing the right side values into
        # RightList till leaf node not found
        while (curr_right != None):
            RightList.append(curr_right)
            curr_right = curr_right.right
 
        # Last node of LeftList
        LeftNode = LeftList[-1]
 
        # Last node of RightList
        RightNode = RightList[-1]
 
        leftVal = LeftNode.data
        rightVal = RightNode.data
 
        # To prevent repetition like 2, 6 and 6, 2
        if (leftVal >= rightVal):
            break
 
        # Delete the last value of LeftList and
        # make the execution to the right side
        if (leftVal + rightVal < tar):
            del LeftList[-1]
            curr_left = LeftNode.right
 
        # Delete the last value of RightList and
        # make the execution to the left side
        elif (leftVal + rightVal > tar):
            del RightList[-1]
            curr_right = RightNode.left
 
        # (left value + right value) = target
        # then print the left value and right value
        # Delete the last value of left and right list
        # and make the left execution to right side
        # and right side execution to left side
        else:
            print(LeftNode.data, RightNode.data)
             
            del RightList[-1]
            del LeftList[-1]
             
            curr_left = LeftNode.right
            curr_right = RightNode.left
 
# Driver code
if __name__ == '__main__':
 
    root = None
    root = AddNode(root, 2)
    root = AddNode(root, 6)
    root = AddNode(root, 5)
    root = AddNode(root, 3)
    root = AddNode(root, 4)
    root = AddNode(root, 1)
    root = AddNode(root, 7)
     
    sum = 8
     
    TargetPair(root, sum)
 
# This code is contributed by mohit kumar 29

C#




// C# program to implement
// the above approach
using System.Collections.Generic;
using System;
 
class GFG
{
 
    // A binary tree node
    public class Node
    {
        public int data;
        public Node left, right, root;
 
        public Node(int data)
        {
            this.data = data;
        }
    }
 
    // Function to add a node to the BST
    public static Node AddNode(Node root, int data)
    {
 
        // If the tree is empty, return a new node
        if (root == null)
        {
            root = new Node(data);
            return root;
        }
 
        // Otherwise, recur down the tree
        if (root.data < data)
            root.right = AddNode(root.right, data);
 
        else if (root.data > data)
            root.left = AddNode(root.left, data);
 
        return root;
    }
 
    // Function to find the target pairs
    public static void TargetPair(Node node, int tar)
    {
 
        // LeftList which stores the left side values
        List<Node> LeftList = new List<Node>();
 
        // RightList which stores the right side values
        List<Node> RightList = new List<Node>();
 
        // curr_left pointer is used for left side execution and
        // curr_right pointer is used for right side execution
        Node curr_left = node;
        Node curr_right = node;
 
        while (curr_left != null || curr_right != null
            || LeftList.Count > 0 && RightList.Count > 0)
        {
 
            // Storing the left side values into LeftList
            // till leaf node not found
            while (curr_left != null)
            {
                LeftList.Add(curr_left);
                curr_left = curr_left.left;
            }
 
            // Storing the right side values into RightList
            // till leaf node not found
            while (curr_right != null)
            {
                RightList.Add(curr_right);
                curr_right = curr_right.right;
            }
 
            // Last node of LeftList
            Node LeftNode = LeftList[LeftList.Count - 1];
 
            // Last node of RightList
            Node RightNode = RightList[RightList.Count - 1];
 
            int leftVal = LeftNode.data;
            int rightVal = RightNode.data;
 
            // To prevent repetition like 2, 6 and 6, 2
            if (leftVal >= rightVal)
                break;
 
            // Delete the last value of LeftList and make
            // the execution to the right side
            if (leftVal + rightVal < tar)
            {
                LeftList.RemoveAt(LeftList.Count - 1);
                curr_left = LeftNode.right;
            }
 
            // Delete the last value of RightList and make
            // the execution to the left side
            else if (leftVal + rightVal > tar)
            {
                RightList.RemoveAt(RightList.Count - 1);
                curr_right = RightNode.left;
            }
 
            // (left value + right value) = target
            // then print the left value and right value
            // Delete the last value of left and right list
            // and make the left execution to right side
            // and right side execution to left side
            else
            {
                Console.WriteLine(LeftNode.data + " " + RightNode.data);
 
                RightList.RemoveAt(RightList.Count - 1);
                LeftList.RemoveAt(LeftList.Count - 1);
                curr_left = LeftNode.right;
                curr_right = RightNode.left;
            }
        }
    }
 
    // Driver code
    public static void Main(String[] b)
    {
 
        Node root = null;
        root = AddNode(root, 2);
        root = AddNode(root, 6);
        root = AddNode(root, 5);
        root = AddNode(root, 3);
        root = AddNode(root, 4);
        root = AddNode(root, 1);
        root = AddNode(root, 7);
        int sum = 8;
        TargetPair(root, sum);
    }
}
 
/* This code contributed by PrinciRaj1992 */

Javascript




<script>
 
// Javascript implementation of the approach
 
// A binary tree node
class Node
{
    constructor(data)
    {
        this.data = data;
        this.left = this.right = null;
    }
}
 
// Function to add a node to the BST
function AddNode(root, data)
{
     
    // If the tree is empty, return a new node
    if (root == null)
    {
        root = new Node(data);
        return root;
    }
 
    // Otherwise, recur down the tree
    if (root.data < data)
        root.right = AddNode(root.right, data);
 
    else if (root.data > data)
        root.left = AddNode(root.left, data);
 
    return root;
}
 
// Function to find the target pairs
function TargetPair(node, tar)
{
    // LeftList which stores the
    // left side values
    let LeftList = [];
 
    // RightList which stores
    // the right side values
    let RightList = [];
 
    // curr_left pointer is used for left
    // side execution and curr_right pointer
    // is used for right side execution
    let curr_left = node;
    let curr_right = node;
 
    while (curr_left != null || curr_right != null ||
           LeftList.length > 0 && RightList.length > 0)
    {
         
        // Storing the left side values into
        // LeftList till leaf node not found
        while (curr_left != null)
        {
            LeftList.push(curr_left);
            curr_left = curr_left.left;
        }
 
        // Storing the right side values into
        // RightList till leaf node not found
        while (curr_right != null)
        {
            RightList.push(curr_right);
            curr_right = curr_right.right;
        }
 
        // Last node of LeftList
        let LeftNode = LeftList[LeftList.length - 1];
 
        // Last node of RightList
        let RightNode = RightList[RightList.length - 1];
 
        let leftVal = LeftNode.data;
        let rightVal = RightNode.data;
 
        // To prevent repetition like 2, 6 and 6, 2
        if (leftVal >= rightVal)
            break;
 
        // Delete the last value of LeftList and make
        // the execution to the right side
        if (leftVal + rightVal < tar)
        {
            LeftList.pop();
            curr_left = LeftNode.right;
        }
 
        // Delete the last value of RightList and make
        // the execution to the left side
        else if (leftVal + rightVal > tar)
        {
            RightList.pop();
            curr_right = RightNode.left;
        }
 
        // (left value + right value) = target
        // then print the left value and right value
        // Delete the last value of left and right list
        // and make the left execution to right side
        // and right side execution to left side
        else
        {
            document.write(LeftNode.data + " " +
                           RightNode.data + "<br>");
 
            RightList.pop();
            LeftList.pop();
            curr_left = LeftNode.right;
            curr_right = RightNode.left;
        }
    }
}
 
// Driver code
let root = null;
root = AddNode(root, 2);
root = AddNode(root, 6);
root = AddNode(root, 5);
root = AddNode(root, 3);
root = AddNode(root, 4);
root = AddNode(root, 1);
root = AddNode(root, 7);
let sum = 8;
 
TargetPair(root, sum);
 
// This code is contributed by patel2127
 
</script>
Output: 
1 7
2 6
3 5

 

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 




My Personal Notes arrow_drop_up
Recommended Articles
Page :