Find a pair with given sum in a Balanced BST - GeeksforGeeks

17 Apr, 2022
Given a Balanced Binary Search Tree and a target sum, write a function that returns true if there is a pair with sum equals to target sum, otherwise return false. Expected time complexity is O(n) and only O(Logn) extra space can be used. Any modification to Binary Search Tree is not allowed. Note that height of a Balanced BST is always O(Logn).
This problem is mainly extension of the previous post. Here we are not allowed to modify the BST.
The Brute Force Solution is to consider each pair in BST and check whether the sum equals to X. The time complexity of this solution will be O(n^2).
A Better Solution is to create an auxiliary array and store the Inorder traversal of BST in the array. The array will be sorted as Inorder traversal of BST always produces sorted data. Once we have the Inorder traversal, we can pair in O(n) time (See this for details). This solution works in O(n) time but requires O(n) auxiliary space.  
C++
Java
Python3
C#
Javascript
#include<bits/stdc++.h>using namespace std; class Node{    public:      int data;      Node* left;      Node* right;      Node(int d)      {          data=d;          left=NULL;          right=NULL;      }}; class BinarySearchTree {     // Root of BST    public:    Node *root;     // Constructor    BinarySearchTree()    {        root = NULL;    }     // Utility function for inorder traversal of the tree    void inorderUtil(Node* node)    {        if (node == NULL)            return;         inorderUtil(node->left);        cout << node->data << " ";        inorderUtil(node->right);    }     // Inorder traversal of the tree    void inorder()    {        inorderUtil(this->root);    }     /* A recursive function to insert a new key in BST */    Node* insertRec(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 (data < root->data)            root->left = insertRec(root->left, data);        else if (data > root->data)            root->right = insertRec(root->right, data);         return root;    }     // This method mainly calls insertRec()    void insert(int key)    {        root = insertRec(root, key);    }      // Method that adds values of given BST into vector    // and hence returns the vector    vector<int> treeToList(Node* node, vector<int>& list)    {        // Base Case        if (node == NULL)            return list;         treeToList(node->left, list);        list.push_back(node->data);        treeToList(node->right, list);         return list;    }     // method that checks if there is a pair present    bool isPairPresent(Node* node, int target)    {        // This list a1 is passed as an argument        // in treeToList method        // which is later on filled by the values of BST        vector<int> a1;         // a2 list contains all the values of BST        // returned by treeToList method        vector<int> a2 = treeToList(node, a1);         int start = 0; // Starting index of a2         int end = (int)a2.size() - 1; // Ending index of a2         while (start < end) {             if (a2[start] + a2[end] == target) // Target Found!            {                cout << "Pair Found: " << a2[start] << " + " << a2[end] << " = " << target << '\n';                return true;            }             if (a2[start] + a2[end]  > target) // decrements end            {                end--;            }             if (a2[start] + a2[end]  < target) // increments start            {                start++;            }        }         cout << "No such values are found!\n";        return false;    }}; // Driver functionint main(){    BinarySearchTree *tree = new BinarySearchTree();    /*            15            /     \        10     20        / \     / \        8 12 16 25 */    tree->insert(15);    tree->insert(10);    tree->insert(20);    tree->insert(8);    tree->insert(12);    tree->insert(16);    tree->insert(25);     tree->isPairPresent(tree->root, 33);}
// Java code to find a pair with given sum// in a Balanced BSTimport java.util.ArrayList; // A binary tree nodeclass Node {     int data;    Node left, right;     Node(int d)    {        data = d;        left = right = null;    }} class BinarySearchTree {     // Root of BST    Node root;     // Constructor    BinarySearchTree()    {        root = null;    }     // Inorder traversal of the tree    void inorder()    {        inorderUtil(this.root);    }     // Utility function for inorder traversal of the tree    void inorderUtil(Node node)    {        if (node == null)            return;         inorderUtil(node.left);        System.out.print(node.data + " ");        inorderUtil(node.right);    }     // This method mainly calls insertRec()    void insert(int key)    {        root = insertRec(root, key);    }     /* A recursive function to insert a new key in BST */    Node insertRec(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 (data < root.data)            root.left = insertRec(root.left, data);        else if (data > root.data)            root.right = insertRec(root.right, data);         return root;    }     // Method that adds values of given BST into ArrayList    // and hence returns the ArrayList    ArrayList<Integer> treeToList(Node node, ArrayList<Integer>                                                 list)    {        // Base Case        if (node == null)            return list;         treeToList(node.left, list);        list.add(node.data);        treeToList(node.right, list);         return list;    }     // method that checks if there is a pair present    boolean isPairPresent(Node node, int target)    {        // This list a1 is passed as an argument        // in treeToList method        // which is later on filled by the values of BST        ArrayList<Integer> a1 = new ArrayList<>();         // a2 list contains all the values of BST        // returned by treeToList method        ArrayList<Integer> a2 = treeToList(node, a1);         int start = 0; // Starting index of a2         int end = a2.size() - 1; // Ending index of a2         while (start < end) {             if (a2.get(start) + a2.get(end) == target) // Target Found!            {                System.out.println("Pair Found: " + a2.get(start) + " + " + a2.get(end) + " "                                   + "= " + target);                return true;            }             if (a2.get(start) + a2.get(end) > target) // decrements end            {                end--;            }             if (a2.get(start) + a2.get(end) < target) // increments start            {                start++;            }        }         System.out.println("No such values are found!");        return false;    }     // Driver function    public static void main(String[] args)    {        BinarySearchTree tree = new BinarySearchTree();        /*                   15                /     \              10      20             / \     /  \            8  12   16  25    */        tree.insert(15);        tree.insert(10);        tree.insert(20);        tree.insert(8);        tree.insert(12);        tree.insert(16);        tree.insert(25);         tree.isPairPresent(tree.root, 33);    }} // This code is contributed by Kamal Rawal
# Python3 code to find a pair with given sum# in a Balanced BSTclass Node:         # Construct to create a new Node    def __init__(self, key):                 self.data = key        self.left = self.right = None # A utility function to insert a new# Node with given key in BSTdef insert(root: Node, key: int):         # If the tree is empty, return a new Node    if root is None:        return Node(key)     # Otherwise, recur down the tree    if root.data > key:        root.left = insert(root.left, key)     elif root.data < key:        root.right = insert(root.right, key)     # return the (unchanged) Node pointer    return root # Function that adds values of given BST into# ArrayList and hence returns the ArrayListdef tree_to_list(root: Node, arr: list):         if not root:        return arr     tree_to_list(root.left, arr)    arr.append(root.data)    tree_to_list(root.right, arr)     return arr # Function that checks if there is a pair presentdef isPairPresent(root: Node, target: int) -> bool:         # This list a1 is passed as an argument    # in treeToList method which is later    # on filled by the values of BST    arr1 = []         # a2 list contains all the values of BST    # returned by treeToList method    arr2 = tree_to_list(root, arr1)         # Starting index of a2    start = 0         # Ending index of a2    end = len(arr2) - 1     while start < end:                 # If target found        if arr2[start] + arr2[end] == target:            print(f"Pair Found: {arr2[start]} + {arr2[end]} = {target}")            return True                     # Decrements end        if arr2[start] + arr2[end] > target:            end -= 1                     # Increments start        if arr2[start] + arr2[end] < target:            start += 1     print("No such values are found!")    return False # Driver codeif __name__ == "__main__":         root = None    root = insert(root, 15)    root = insert(root, 10)    root = insert(root, 20)    root = insert(root, 8)    root = insert(root, 12)    root = insert(root, 16)    root = insert(root, 25)     isPairPresent(root, 33) # This code is contributed by shindesharad71
// C# code to find a pair with given sum// in a Balanced BSTusing System;using System.Collections.Generic; // A binary tree nodepublic class Node {     public int data;    public Node left, right;     public Node(int d)    {        data = d;        left = right = null;    }} public class BinarySearchTree {     // Root of BST    Node root;     // Constructor    BinarySearchTree()    {        root = null;    }     // Inorder traversal of the tree    void inorder()    {        inorderUtil(this.root);    }     // Utility function for inorder traversal of the tree    void inorderUtil(Node node)    {        if (node == null)            return;         inorderUtil(node.left);        Console.Write(node.data + " ");        inorderUtil(node.right);    }     // This method mainly calls insertRec()    void insert(int key)    {        root = insertRec(root, key);    }     /* A recursive function to insert a new key in BST */    Node insertRec(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 (data < root.data)            root.left = insertRec(root.left, data);        else if (data > root.data)            root.right = insertRec(root.right, data);         return root;    }     // Method that adds values of given BST into ArrayList    // and hence returns the ArrayList    List<int> treeToList(Node node, List<int> list)    {        // Base Case        if (node == null)            return list;         treeToList(node.left, list);        list.Add(node.data);        treeToList(node.right, list);         return list;    }     // method that checks if there is a pair present    bool isPairPresent(Node node, int target)    {        // This list a1 is passed as an argument        // in treeToList method        // which is later on filled by the values of BST        List<int> a1 = new List<int>();         // a2 list contains all the values of BST        // returned by treeToList method        List<int> a2 = treeToList(node, a1);         int start = 0; // Starting index of a2         int end = a2.Count - 1; // Ending index of a2         while (start < end) {             if (a2[start] + a2[end] == target) // Target Found!            {                Console.WriteLine("Pair Found: " + a2[start] + " + " + a2[end] + " "                                  + "= " + target);                return true;            }             if (a2[start] + a2[end] > target) // decrements end            {                end--;            }             if (a2[start] + a2[end] < target) // increments start            {                start++;            }        }         Console.WriteLine("No such values are found!");        return false;    }     // Driver code    public static void Main(String[] args)    {        BinarySearchTree tree = new BinarySearchTree();        /*                15                /     \            10     20            / \     / \            8 12 16 25 */        tree.insert(15);        tree.insert(10);        tree.insert(20);        tree.insert(8);        tree.insert(12);        tree.insert(16);        tree.insert(25);         tree.isPairPresent(tree.root, 33);    }} // This code contributed by Rajput-Ji
<script>       // JavaScript code to find a pair with given sum      // in a Balanced BST      // A binary tree node      class Node {        constructor(d) {          this.data = d;          this.left = null;          this.right = null;        }      }       class BinarySearchTree {        // Constructor        constructor() {          this.root = null;        }         // Inorder traversal of the tree        inorder() {          this.inorderUtil(this.root);        }         // Utility function for inorder traversal of the tree        inorderUtil(node) {          if (node == null) return;           this.inorderUtil(node.left);          document.write(node.data + " ");          this.inorderUtil(node.right);        }         // This method mainly calls insertRec()        insert(key) {          this.root = this.insertRec(this.root, key);        }         /* A recursive function to insert a new key in BST */        insertRec(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 (data < root.data)          root.left = this.insertRec(root.left, data);          else if (data > root.data)            root.right = this.insertRec(root.right, data);           return root;        }         // Method that adds values of given BST into ArrayList        // and hence returns the ArrayList        treeToList(node, list) {          // Base Case          if (node == null) return list;           this.treeToList(node.left, list);          list.push(node.data);          this.treeToList(node.right, list);           return list;        }         // method that checks if there is a pair present        isPairPresent(node, target) {          // This list a1 is passed as an argument          // in treeToList method          // which is later on filled by the values of BST          var a1 = [];           // a2 list contains all the values of BST          // returned by treeToList method          var a2 = this.treeToList(node, a1);           var start = 0; // Starting index of a2           var end = a2.length - 1; // Ending index of a2           while (start < end) {            if (a2[start] + a2[end] == target) {              // Target Found!              document.write(                "Pair Found: " +                  a2[start] +                  " + " +                  a2[end] +                  " " +                  "= " +                  target +                  "<br>"              );              return true;            }             if (a2[start] + a2[end] > target) {              // decrements end              end--;            }             if (a2[start] + a2[end] < target) {              // increments start              start++;            }          }           document.write("No such values are found!");          return false;        }      }      // Driver code      var tree = new BinarySearchTree();      /*                15                /     \            10     20            / \     / \            8 12 16 25 */      tree.insert(15);      tree.insert(10);      tree.insert(20);      tree.insert(8);      tree.insert(12);      tree.insert(16);      tree.insert(25);       tree.isPairPresent(tree.root, 33);       </script>
Output :  
Pair Found: 8 + 25 = 33
Complexity Analysis: Time Complexity: O(n). Inorder Traversal of BST takes linear time.Auxiliary Space: O(n). Use of array for storing the Inorder Traversal.
Time Complexity: O(n). Inorder Traversal of BST takes linear time.
Auxiliary Space: O(n). Use of array for storing the Inorder Traversal.
A space optimized solution is discussed in previous post. The idea was to first in-place convert BST to Doubly Linked List (DLL), then find pair in sorted DLL in O(n) time. This solution takes O(n) time and O(Logn) extra space, but it modifies the given BST.
The solution discussed below takes O(n) time, O(Logn) space and doesn’t modify BST. The idea is same as finding the pair in sorted array (See method 1 of this for details). We traverse BST in Normal Inorder and Reverse Inorder simultaneously. In reverse inorder, we start from the rightmost node which is the maximum value node. In normal inorder, we start from the left most node which is minimum value node. We add sum of current nodes in both traversals and compare this sum with given target sum. If the sum is same as target sum, we return true. If the sum is more than target sum, we move to next node in reverse inorder traversal, otherwise we move to next node in normal inorder traversal. If any of the traversals is finished without finding a pair, we return false.
Following is the implementation of this approach. 
C++
C
Java
Python3
C#
Javascript
/* In a balanced binary search treeisPairPresent two element which sums toa given value time O(n) space O(logn) */#include <bits/stdc++.h>using namespace std;#define MAX_SIZE 100 // A BST nodeclass node {public:    int val;    node *left, *right;}; // Stack typeclass Stack {public:    int size;    int top;    node** array;}; // A utility function to create a stack of given sizeStack* createStack(int size){    Stack* stack = new Stack();    stack->size = size;    stack->top = -1;    stack->array = new node*[(stack->size * sizeof(node*))];    return stack;} // BASIC OPERATIONS OF STACKint isFull(Stack* stack){    return stack->top - 1 == stack->size;} int isEmpty(Stack* stack){    return stack->top == -1;} void push(Stack* stack, node* node){    if (isFull(stack))        return;    stack->array[++stack->top] = node;} node* pop(Stack* stack){    if (isEmpty(stack))        return NULL;    return stack->array[stack->top--];} // Returns true if a pair with target// sum exists in BST, otherwise falsebool isPairPresent(node* root, int target){    // Create two stacks. s1 is used for    // normal inorder traversal and s2 is    // used for reverse inorder traversal    Stack* s1 = createStack(MAX_SIZE);    Stack* s2 = createStack(MAX_SIZE);     // Note the sizes of stacks is MAX_SIZE,    // we can find the tree size and fix stack size    // as O(Logn) for balanced trees like AVL and Red Black    // tree. We have used MAX_SIZE to keep the code simple     // done1, val1 and curr1 are used for    // normal inorder traversal using s1    // done2, val2 and curr2 are used for    // reverse inorder traversal using s2    bool done1 = false, done2 = false;    int val1 = 0, val2 = 0;    node *curr1 = root, *curr2 = root;     // The loop will break when we either find a pair or one of the two    // traversals is complete    while (1) {        // Find next node in normal Inorder        // traversal. See following post        // https:// www.geeksforgeeks.org/inorder-tree-traversal-without-recursion/        while (done1 == false) {            if (curr1 != NULL) {                push(s1, curr1);                curr1 = curr1->left;            }            else {                if (isEmpty(s1))                    done1 = 1;                else {                    curr1 = pop(s1);                    val1 = curr1->val;                    curr1 = curr1->right;                    done1 = 1;                }            }        }         // Find next node in REVERSE Inorder traversal. The only        // difference between above and below loop is, in below loop        // right subtree is traversed before left subtree        while (done2 == false) {            if (curr2 != NULL) {                push(s2, curr2);                curr2 = curr2->right;            }            else {                if (isEmpty(s2))                    done2 = 1;                else {                    curr2 = pop(s2);                    val2 = curr2->val;                    curr2 = curr2->left;                    done2 = 1;                }            }        }         // If we find a pair, then print the pair and return. The first        // condition makes sure that two same values are not added        if ((val1 != val2) && (val1 + val2) == target) {            cout << "Pair Found: " << val1 << "+ " << val2 << " = " << target << endl;            return true;        }         // If sum of current values is smaller,        // then move to next node in        // normal inorder traversal        else if ((val1 + val2) < target)            done1 = false;         // If sum of current values is greater,        // then move to next node in        // reverse inorder traversal        else if ((val1 + val2) > target)            done2 = false;         // If any of the inorder traversals is        // over, then there is no pair        // so return false        if (val1 >= val2)            return false;    }} // A utility function to create BST nodenode* NewNode(int val){    node* tmp = new node();    tmp->val = val;    tmp->right = tmp->left = NULL;    return tmp;} // Driver program to test above functionsint main(){    /*                15                / \            10 20            / \ / \            8 12 16 25 */    node* root = NewNode(15);    root->left = NewNode(10);    root->right = NewNode(20);    root->left->left = NewNode(8);    root->left->right = NewNode(12);    root->right->left = NewNode(16);    root->right->right = NewNode(25);     int target = 33;    if (isPairPresent(root, target) == false)        cout << "\nNo such values are found\n";    return 0;} // This code is contributed by rathbhupendra
/* In a balanced binary search tree isPairPresent two element which sums to   a given value time O(n) space O(logn) */#include <stdio.h>#include <stdlib.h>#define MAX_SIZE 100 // A BST nodestruct node {    int val;    struct node *left, *right;}; // Stack typestruct Stack {    int size;    int top;    struct node** array;}; // A utility function to create a stack of given sizestruct Stack* createStack(int size){    struct Stack* stack = (struct Stack*)malloc(sizeof(struct Stack));    stack->size = size;    stack->top = -1;    stack->array = (struct node**)malloc(stack->size * sizeof(struct node*));    return stack;} // BASIC OPERATIONS OF STACKint isFull(struct Stack* stack){    return stack->top - 1 == stack->size;} int isEmpty(struct Stack* stack){    return stack->top == -1;} void push(struct Stack* stack, struct node* node){    if (isFull(stack))        return;    stack->array[++stack->top] = node;} struct node* pop(struct Stack* stack){    if (isEmpty(stack))        return NULL;    return stack->array[stack->top--];} // Returns true if a pair with target sum exists in BST, otherwise falsebool isPairPresent(struct node* root, int target){    // Create two stacks. s1 is used for normal inorder traversal    // and s2 is used for reverse inorder traversal    struct Stack* s1 = createStack(MAX_SIZE);    struct Stack* s2 = createStack(MAX_SIZE);     // Note the sizes of stacks is MAX_SIZE, we can find the tree size and    // fix stack size as O(Logn) for balanced trees like AVL and Red Black    // tree. We have used MAX_SIZE to keep the code simple     // done1, val1 and curr1 are used for normal inorder traversal using s1    // done2, val2 and curr2 are used for reverse inorder traversal using s2    bool done1 = false, done2 = false;    int val1 = 0, val2 = 0;    struct node *curr1 = root, *curr2 = root;     // The loop will break when we either find a pair or one of the two    // traversals is complete    while (1) {        // Find next node in normal Inorder traversal. See following post        // https:// www.geeksforgeeks.org/inorder-tree-traversal-without-recursion/        while (done1 == false) {            if (curr1 != NULL) {                push(s1, curr1);                curr1 = curr1->left;            }            else {                if (isEmpty(s1))                    done1 = 1;                else {                    curr1 = pop(s1);                    val1 = curr1->val;                    curr1 = curr1->right;                    done1 = 1;                }            }        }         // Find next node in REVERSE Inorder traversal. The only        // difference between above and below loop is, in below loop        // right subtree is traversed before left subtree        while (done2 == false) {            if (curr2 != NULL) {                push(s2, curr2);                curr2 = curr2->right;            }            else {                if (isEmpty(s2))                    done2 = 1;                else {                    curr2 = pop(s2);                    val2 = curr2->val;                    curr2 = curr2->left;                    done2 = 1;                }            }        }         // If we find a pair, then print the pair and return. The first        // condition makes sure that two same values are not added        if ((val1 != val2) && (val1 + val2) == target) {            printf("\n Pair Found: %d + %d = %d\n", val1, val2, target);            return true;        }         // If sum of current values is smaller, then move to next node in        // normal inorder traversal        else if ((val1 + val2) < target)            done1 = false;         // If sum of current values is greater, then move to next node in        // reverse inorder traversal        else if ((val1 + val2) > target)            done2 = false;         // If any of the inorder traversals is over, then there is no pair        // so return false        if (val1 >= val2)            return false;    }} // A utility function to create BST nodestruct node* NewNode(int val){    struct node* tmp = (struct node*)malloc(sizeof(struct node));    tmp->val = val;    tmp->right = tmp->left = NULL;    return tmp;} // Driver program to test above functionsint main(){    /*                   15                /     \              10      20             / \     /  \            8  12   16  25    */    struct node* root = NewNode(15);    root->left = NewNode(10);    root->right = NewNode(20);    root->left->left = NewNode(8);    root->left->right = NewNode(12);    root->right->left = NewNode(16);    root->right->right = NewNode(25);     int target = 33;    if (isPairPresent(root, target) == false)        printf("\n No such values are found\n");     getchar();    return 0;}
/* In a balanced binary search treeisPairPresent two element which sums toa given value time O(n) space O(logn) */import java.util.*;class GFG{static final int MAX_SIZE= 100; // A BST nodestatic class node{    int val;    node left, right;}; // Stack typestatic class Stack{    int size;    int top;    node []array;}; // A utility function to create a stack of given sizestatic Stack createStack(int size){    Stack stack = new Stack();    stack.size = size;    stack.top = -1;    stack.array = new node[stack.size];    return stack;} // BASIC OPERATIONS OF STACKstatic int isFull(Stack stack){    return (stack.top - 1 == stack.size)?1:0 ;} static int isEmpty(Stack stack){    return stack.top == -1?1:0;} static void push(Stack stack, node node){    if (isFull(stack)==1)        return;    stack.array[++stack.top] = node;} static node pop(Stack stack){    if (isEmpty(stack) == 1)        return null;    return stack.array[stack.top--];} // Returns true if a pair with target// sum exists in BST, otherwise falsestatic boolean isPairPresent(node root, int target){    // Create two stacks. s1 is used for    // normal inorder traversal and s2 is    // used for reverse inorder traversal    Stack s1 = createStack(MAX_SIZE);    Stack s2 = createStack(MAX_SIZE);     // Note the sizes of stacks is MAX_SIZE,    // we can find the tree size and fix stack size    // as O(Logn) for balanced trees like AVL and Red Black    // tree. We have used MAX_SIZE to keep the code simple     // done1, val1 and curr1 are used for    // normal inorder traversal using s1    // done2, val2 and curr2 are used for    // reverse inorder traversal using s2    boolean done1 = false, done2 = false;    int val1 = 0, val2 = 0;    node curr1 = root, curr2 = root;     // The loop will break when we either  // find a pair or one of the two    // traversals is complete    while (true)    {               // Find next node in normal Inorder        // traversal. See following post        // https:// www.geeksforgeeks.org/inorder-tree-traversal-without-recursion/        while (done1 == false)        {            if (curr1 != null)            {                push(s1, curr1);                curr1 = curr1.left;            }            else            {                if (isEmpty(s1) == 1)                    done1 = true;                else                {                    curr1 = pop(s1);                    val1 = curr1.val;                    curr1 = curr1.right;                    done1 = true;                }            }        }         // Find next node in REVERSE Inorder traversal. The only        // difference between above and below loop is, in below loop        // right subtree is traversed before left subtree        while (done2 == false)        {            if (curr2 != null)            {                push(s2, curr2);                curr2 = curr2.right;            }            else {                if (isEmpty(s2) == 1)                    done2 = true;                else {                    curr2 = pop(s2);                    val2 = curr2.val;                    curr2 = curr2.left;                    done2 = true;                }            }        }         // If we find a pair, then print the pair and return. The first        // condition makes sure that two same values are not added        if ((val1 != val2) && (val1 + val2) == target)        {            System.out.print("Pair Found: " +                             val1+ "+ " +                             val2+ " = " +                              target +"\n");            return true;        }         // If sum of current values is smaller,        // then move to next node in        // normal inorder traversal        else if ((val1 + val2) < target)            done1 = false;         // If sum of current values is greater,        // then move to next node in        // reverse inorder traversal        else if ((val1 + val2) > target)            done2 = false;         // If any of the inorder traversals is        // over, then there is no pair        // so return false        if (val1 >= val2)            return false;    }} // A utility function to create BST nodestatic node NewNode(int val){    node tmp = new node();    tmp.val = val;    tmp.right = tmp.left = null;    return tmp;} // Driver program to test above functionspublic static void main(String[] args){    /*                15                / \            10 20            / \ / \            8 12 16 25 */    node root = NewNode(15);    root.left = NewNode(10);    root.right = NewNode(20);    root.left.left = NewNode(8);    root.left.right = NewNode(12);    root.right.left = NewNode(16);    root.right.right = NewNode(25);     int target = 33;    if (isPairPresent(root, target) == false)        System.out.print("\nNo such values are found\n");}} // This code is contributed by aashish1995
#  In a balanced binary search tree# isPairPresent two element which sums to# a given value time O(n) space O(logn)MAX_SIZE= 100 # A BST nodeclass Node:    def __init__(self,val):        self.val = val        self.left = self.right = None # Stack typeclass Stack:    def __init__(self):        self.size = 0        self.top = 0        self.array = [] # A utility function to create a stack of given sizedef createStack(size):    stack = Stack()    stack.size = size    stack.top = -1    stack.array = [0 for i in range(stack.size)]    return stack # BASIC OPERATIONS OF STACKdef isFull(stack):    return 1 if(stack.top - 1 == stack.size) else 0 def isEmpty(stack):    return 1 if stack.top == -1 else 0 def push(stack,node):    if (isFull(stack)==1):        return    stack.array[stack.top+1] = node    stack.top += 1 def pop(stack):    if (isEmpty(stack) == 1):        return None    x = stack.array[stack.top]    stack.top -= 1    return x # Returns true if a pair with target# sum exists in BST, otherwise Falsedef isPairPresent(root,target):    # Create two stacks. s1 is used for    # normal inorder traversal and s2 is    # used for reverse inorder traversal    s1 = createStack(MAX_SIZE)    s2 = createStack(MAX_SIZE)     # Note the sizes of stacks is MAX_SIZE,    # we can find the tree size and fix stack size    # as O(Logn) for balanced trees like AVL and Red Black    # tree. We have used MAX_SIZE to keep the code simple     # done1, val1 and curr1 are used for    # normal inorder traversal using s1    # done2, val2 and curr2 are used for    # reverse inorder traversal using s2    done1,done2 = False,False    val1,val2 = 0,0    curr1,curr2 = root,root     # The loop will break when we either# find a pair or one of the two    # traversals is complete    while (True):             # Find next node in normal Inorder        # traversal. See following post        # https:# www.geeksforgeeks.org/inorder-tree-traversal-without-recursion/        while (done1 == False):            if (curr1 != None):                push(s1, curr1)                curr1 = curr1.left            else:                if (isEmpty(s1) == 1):                    done1 = True                else:                    curr1 = pop(s1)                    val1 = curr1.val                    curr1 = curr1.right                    done1 = True         # Find next node in REVERSE Inorder traversal. The only        # difference between above and below loop is, in below loop        # right subtree is traversed before left subtree        while (done2 == False):            if (curr2 != None):                push(s2, curr2)                curr2 = curr2.right            else:                if (isEmpty(s2) == 1):                    done2 = True                else:                    curr2 = pop(s2)                    val2 = curr2.val                    curr2 = curr2.left                    done2 = True         # If we find a pair, then print the pair and return. The first        # condition makes sure that two same values are not added        if ((val1 != val2) and (val1 + val2) == target):            print("Pair Found: " +str(val1)+ " + " +str(val2)+ " = " +str(target))            return True         # If sum of current values is smaller,        # then move to next node in        # normal inorder traversal        elif ((val1 + val2) < target):            done1 = False         # If sum of current values is greater,        # then move to next node in        # reverse inorder traversal        elif ((val1 + val2) > target):            done2 = False         # If any of the inorder traversals is        # over, then there is no pair        # so return False        if (val1 >= val2):            return False # Driver program to test above functions             #     15            #     / \            # 10 20            # / \ / \            # 8 12 16 25root = Node(15)root.left = Node(10)root.right = Node(20)root.left.left = Node(8)root.left.right = Node(12)root.right.left = Node(16)root.right.right = Node(25) target = 33if (isPairPresent(root, target) == False):    print("<br>No such values are found")     # This code is contributed by shinjanpatra
/* In a balanced binary search treeisPairPresent two element which sums toa given value time O(n) space O(logn) */using System;using System.Collections.Generic; public class GFG{static readonly int MAX_SIZE= 100; // A BST nodepublic class node{    public int val;    public node left, right;}; // Stack typepublic class Stack{    public int size;    public int top;    public node []array;}; // A utility function to create a stack of given sizestatic Stack createStack(int size){    Stack stack = new Stack();    stack.size = size;    stack.top = -1;    stack.array = new node[stack.size];    return stack;} // BASIC OPERATIONS OF STACKstatic int isFull(Stack stack){    return (stack.top - 1 == stack.size) ? 1 : 0 ;} static int isEmpty(Stack stack){    return stack.top == -1?1:0;} static void push(Stack stack, node node){    if (isFull(stack)==1)        return;    stack.array[++stack.top] = node;} static node pop(Stack stack){    if (isEmpty(stack) == 1)        return null;    return stack.array[stack.top--];} // Returns true if a pair with target// sum exists in BST, otherwise falsestatic bool isPairPresent(node root, int target){    // Create two stacks. s1 is used for    // normal inorder traversal and s2 is    // used for reverse inorder traversal    Stack s1 = createStack(MAX_SIZE);    Stack s2 = createStack(MAX_SIZE);     // Note the sizes of stacks is MAX_SIZE,    // we can find the tree size and fix stack size    // as O(Logn) for balanced trees like AVL and Red Black    // tree. We have used MAX_SIZE to keep the code simple     // done1, val1 and curr1 are used for    // normal inorder traversal using s1    // done2, val2 and curr2 are used for    // reverse inorder traversal using s2    bool done1 = false, done2 = false;    int val1 = 0, val2 = 0;    node curr1 = root, curr2 = root;     // The loop will break when we either  // find a pair or one of the two    // traversals is complete    while (true)    {               // Find next node in normal Inorder        // traversal. See following post        // https:// www.geeksforgeeks.org/inorder-tree-traversal-without-recursion/        while (done1 == false)        {            if (curr1 != null)            {                push(s1, curr1);                curr1 = curr1.left;            }            else            {                if (isEmpty(s1) == 1)                    done1 = true;                else                {                    curr1 = pop(s1);                    val1 = curr1.val;                    curr1 = curr1.right;                    done1 = true;                }            }        }         // Find next node in REVERSE Inorder traversal. The only        // difference between above and below loop is, in below loop        // right subtree is traversed before left subtree        while (done2 == false)        {            if (curr2 != null)            {                push(s2, curr2);                curr2 = curr2.right;            }            else {                if (isEmpty(s2) == 1)                    done2 = true;                else {                    curr2 = pop(s2);                    val2 = curr2.val;                    curr2 = curr2.left;                    done2 = true;                }            }        }         // If we find a pair, then print the pair and return. The first        // condition makes sure that two same values are not added        if ((val1 != val2) && (val1 + val2) == target)        {            Console.Write("Pair Found: " +                             val1+ "+ " +                             val2+ " = " +                              target +"\n");            return true;        }         // If sum of current values is smaller,        // then move to next node in        // normal inorder traversal        else if ((val1 + val2) < target)            done1 = false;         // If sum of current values is greater,        // then move to next node in        // reverse inorder traversal        else if ((val1 + val2) > target)            done2 = false;         // If any of the inorder traversals is        // over, then there is no pair        // so return false        if (val1 >= val2)            return false;    }} // A utility function to create BST nodestatic node NewNode(int val){    node tmp = new node();    tmp.val = val;    tmp.right = tmp.left = null;    return tmp;} // Driver program to test above functionspublic static void Main(String[] args){    /*                15                / \            10 20            / \ / \            8 12 16 25 */    node root = NewNode(15);    root.left = NewNode(10);    root.right = NewNode(20);    root.left.left = NewNode(8);    root.left.right = NewNode(12);    root.right.left = NewNode(16);    root.right.right = NewNode(25);     int target = 33;    if (isPairPresent(root, target) == false)        Console.Write("\nNo such values are found\n");}} // This code is contributed by aashish1995
<script>/* In a balanced binary search treeisPairPresent two element which sums toa given value time O(n) space O(logn) */ let MAX_SIZE= 100; // A BST nodeclass Node{    constructor(val)    {        this.val = val;        this.left = this.right = null;    }} // Stack typeclass Stack{    constructor()    {        this.size = 0;        this.top = 0;        this.array;    }} // A utility function to create a stack of given sizefunction createStack(size){    let stack = new Stack();    stack.size = size;    stack.top = -1;    stack.array = new Array(stack.size);    return stack;} // BASIC OPERATIONS OF STACKfunction isFull(stack){    return (stack.top - 1 == stack.size)?1:0 ;} function isEmpty(stack){    return stack.top == -1?1:0;} function push(stack,node){    if (isFull(stack)==1)        return;    stack.array[++stack.top] = node;} function pop(stack){    if (isEmpty(stack) == 1)        return null;    return stack.array[stack.top--];} // Returns true if a pair with target// sum exists in BST, otherwise falsefunction isPairPresent(root,target){    // Create two stacks. s1 is used for    // normal inorder traversal and s2 is    // used for reverse inorder traversal    let s1 = createStack(MAX_SIZE);    let s2 = createStack(MAX_SIZE);      // Note the sizes of stacks is MAX_SIZE,    // we can find the tree size and fix stack size    // as O(Logn) for balanced trees like AVL and Red Black    // tree. We have used MAX_SIZE to keep the code simple      // done1, val1 and curr1 are used for    // normal inorder traversal using s1    // done2, val2 and curr2 are used for    // reverse inorder traversal using s2    let done1 = false, done2 = false;    let val1 = 0, val2 = 0;    let curr1 = root, curr2 = root;      // The loop will break when we either  // find a pair or one of the two    // traversals is complete    while (true)    {                // Find next node in normal Inorder        // traversal. See following post        // https:// www.geeksforgeeks.org/inorder-tree-traversal-without-recursion/        while (done1 == false)        {            if (curr1 != null)            {                push(s1, curr1);                curr1 = curr1.left;            }            else            {                if (isEmpty(s1) == 1)                    done1 = true;                else                {                    curr1 = pop(s1);                    val1 = curr1.val;                    curr1 = curr1.right;                    done1 = true;                }            }        }          // Find next node in REVERSE Inorder traversal. The only        // difference between above and below loop is, in below loop        // right subtree is traversed before left subtree        while (done2 == false)        {            if (curr2 != null)            {                push(s2, curr2);                curr2 = curr2.right;            }            else {                if (isEmpty(s2) == 1)                    done2 = true;                else {                    curr2 = pop(s2);                    val2 = curr2.val;                    curr2 = curr2.left;                    done2 = true;                }            }        }          // If we find a pair, then print the pair and return. The first        // condition makes sure that two same values are not added        if ((val1 != val2) && (val1 + val2) == target)        {            document.write("Pair Found: " +                             val1+ "+ " +                             val2+ " = " +                             target +"<br>");            return true;        }          // If sum of current values is smaller,        // then move to next node in        // normal inorder traversal        else if ((val1 + val2) < target)            done1 = false;          // If sum of current values is greater,        // then move to next node in        // reverse inorder traversal        else if ((val1 + val2) > target)            done2 = false;          // If any of the inorder traversals is        // over, then there is no pair        // so return false        if (val1 >= val2)            return false;    }} // Driver program to test above functions/*                15                / \            10 20            / \ / \            8 12 16 25 */let root = new Node(15);root.left = new Node(10);root.right = new Node(20);root.left.left = new Node(8);root.left.right = new Node(12);root.right.left = new Node(16);root.right.right = new Node(25); let target = 33;if (isPairPresent(root, target) == false)    document.write("<br>No such values are found<br>");     // This code is contributed by avanitrachhadiya2155</script>
Output: 
 Pair Found: 8 + 25 = 33
Complexity Analysis: Time Complexity: O(n). Inorder Traversal of BST takes linear time.Auxiliary Space: O(logn). The stack holds log N values as at a single time
Time Complexity: O(n). Inorder Traversal of BST takes linear time.
Auxiliary Space: O(logn). The stack holds log N values as at a single time
 
https://www.youtube.com/embed/TvAFvAoS6s8?list=PLqM7alHXFySHCXD7r1J0ky9Zg_GBB1dbk 
This article is compiled by Kumar and reviewed by GeeksforGeeks team. Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above. 
 
rathbhupendra
Rajput-Ji
bidibaaz123
aashish1995
itwasme
shindesharad71
avanitrachhadiya2155
ashutoshsinghgeeksforgeeks
shinjanpatra
Amazon
OYO Rooms
Snapdeal
Visa
VMWare
Binary Search Tree
VMWare
Amazon
OYO Rooms
Snapdeal
Visa
Binary Search Tree
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Comments
Old Comments
Sorted Array to Balanced BST
Inorder Successor in Binary Search Tree
Optimal Binary Search Tree | DP-24
Two nodes of a BST are swapped, correct the BST
Find the node with minimum value in a Binary Search Tree
Find k-th smallest element in BST (Order Statistics in BST)
Overview of Data Structures | Set 2 (Binary Tree, BST, Heap and Hash)
Difference between Binary Tree and Binary Search Tree
Lowest Common Ancestor in a Binary Search Tree.
Convert a normal BST to Balanced BST