Find if there is a triplet in a Balanced BST that adds to zero

20 Jun, 2022
Given a Balanced Binary Search Tree (BST), write a function isTripletPresent() that returns true if there is a triplet in given BST with sum equals to 0, otherwise returns false. Expected time complexity is O(n^2) and only O(Logn) extra space can be used. You can modify given Binary Search Tree. Note that height of a Balanced BST is always O(Logn) For example, isTripletPresent() should return true for following BST because there is a triplet with sum 0, the triplet is {-13, 6, 7}. 
 
The Brute Force Solution is to consider each triplet in BST and check whether the sum adds upto zero. The time complexity of this solution will be O(n^3).A Better Solution is to create an auxiliary array and store 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 use method 2 of this post to find the triplet with sum equals to 0. This solution works in O(n^2) time, but requires O(n) auxiliary space.
Following is the solution that works in O(n^2) time and uses O(Logn) extra space: 
Convert given BST to Doubly Linked List (DLL) Now iterate through every node of DLL and if the key of node is negative, then find a pair in DLL with sum equal to key of current node multiplied by -1. To find the pair, we can use the approach used in hasArrayTwoCandidates() in method 1 of this post. 
Convert given BST to Doubly Linked List (DLL) 
Now iterate through every node of DLL and if the key of node is negative, then find a pair in DLL with sum equal to key of current node multiplied by -1. To find the pair, we can use the approach used in hasArrayTwoCandidates() in method 1 of this post. 
Implementation: 
C++
C
Java
Python3
C#
Javascript
// A C++ program to check if there// is a triplet with sum equal to 0 in// a given BST#include <bits/stdc++.h>using namespace std; // A BST node has key, and left and right pointersclass node{    public:    int key;    node *left;    node *right;}; // A function to convert given BST to Doubly// Linked List. left pointer is used// as previous pointer and right pointer// is used as next pointer. The function// sets *head to point to first and *tail// to point to last node of converted DLLvoid convertBSTtoDLL(node* root, node** head, node** tail){    // Base case    if (root == NULL)        return;     // First convert the left subtree    if (root->left)        convertBSTtoDLL(root->left, head, tail);     // Then change left of current root    // as last node of left subtree    root->left = *tail;     // If tail is not NULL, then set right    // of tail as root, else current    // node is head    if (*tail)        (*tail)->right = root;    else        *head = root;     // Update tail    *tail = root;     // Finally, convert right subtree    if (root->right)        convertBSTtoDLL(root->right, head, tail);} // This function returns true if there// is pair in DLL with sum equal to given// sum. The algorithm is similar to hasArrayTwoCandidates()// in method 1 of http://tinyurl.com/dy6palrbool isPresentInDLL(node* head, node* tail, int sum){    while (head != tail)    {        int curr = head->key + tail->key;        if (curr == sum)            return true;        else if (curr > sum)            tail = tail->left;        else            head = head->right;    }    return false;} // The main function that returns// true if there is a 0 sum triplet in// BST otherwise returns falsebool isTripletPresent(node *root){    // Check if the given BST is empty    if (root == NULL)    return false;     // Convert given BST to doubly linked list. head and tail store the    // pointers to first and last nodes in DLLL    node* head = NULL;    node* tail = NULL;    convertBSTtoDLL(root, &head, &tail);     // Now iterate through every node and    // find if there is a pair with sum    // equal to -1 * head->key where head is current node    while ((head->right != tail) && (head->key < 0))    {        // If there is a pair with sum        // equal to -1*head->key, then return        // true else move forward        if (isPresentInDLL(head->right, tail, -1*head->key))            return true;        else            head = head->right;    }     // If we reach here, then    // there was no 0 sum triplet    return false;} // A utility function to create// a new BST node with key as given numnode* newNode(int num){    node* temp = new node();    temp->key = num;    temp->left = temp->right = NULL;    return temp;} // A utility function to insert a given key to BSTnode* insert(node* root, int key){    if (root == NULL)    return newNode(key);    if (root->key > key)        root->left = insert(root->left, key);    else        root->right = insert(root->right, key);    return root;} // Driver codeint main(){    node* root = NULL;    root = insert(root, 6);    root = insert(root, -13);    root = insert(root, 14);    root = insert(root, -8);    root = insert(root, 15);    root = insert(root, 13);    root = insert(root, 7);    if (isTripletPresent(root))        cout << "Present";    else        cout << "Not Present";    return 0;} // This code is contributed by rathbhupendra
// A C program to check if there is a triplet with sum equal to 0 in// a given BST#include<stdio.h> // A BST node has key, and left and right pointersstruct node{    int key;    struct node *left;    struct node *right;}; // A function to convert given BST to Doubly Linked List. left pointer is used// as previous pointer and right pointer is used as next pointer. The function// sets *head to point to first and *tail to point to last node of converted DLLvoid convertBSTtoDLL(node* root, node** head, node** tail){    // Base case    if (root == NULL)        return;     // First convert the left subtree    if (root->left)        convertBSTtoDLL(root->left, head, tail);     // Then change left of current root as last node of left subtree    root->left = *tail;     // If tail is not NULL, then set right of tail as root, else current    // node is head    if (*tail)        (*tail)->right = root;    else        *head = root;     // Update tail    *tail = root;     // Finally, convert right subtree    if (root->right)        convertBSTtoDLL(root->right, head, tail);} // This function returns true if there is pair in DLL with sum equal// to given sum. The algorithm is similar to hasArrayTwoCandidates()// in method 1 of http://tinyurl.com/dy6palrbool isPresentInDLL(node* head, node* tail, int sum){    while (head != tail)    {        int curr = head->key + tail->key;        if (curr == sum)            return true;        else if (curr > sum)            tail = tail->left;        else            head = head->right;    }    return false;} // The main function that returns true if there is a 0 sum triplet in// BST otherwise returns falsebool isTripletPresent(node *root){    // Check if the given  BST is empty    if (root == NULL)       return false;     // Convert given BST to doubly linked list.  head and tail store the    // pointers to first and last nodes in DLLL    node* head = NULL;    node* tail = NULL;    convertBSTtoDLL(root, &head, &tail);     // Now iterate through every node and find if there is a pair with sum    // equal to -1 * head->key where head is current node    while ((head->right != tail) && (head->key < 0))    {        // If there is a pair with sum equal to  -1*head->key, then return        // true else move forward        if (isPresentInDLL(head->right, tail, -1*head->key))            return true;        else            head = head->right;    }     // If we reach here, then there was no 0 sum triplet    return false;} // A utility function to create a new BST node with key as given numnode* newNode(int num){    node* temp = new node;    temp->key = num;    temp->left = temp->right = NULL;    return temp;} // A utility function to insert a given key to BSTnode* insert(node* root, int key){    if (root == NULL)       return newNode(key);    if (root->key > key)       root->left = insert(root->left, key);    else       root->right = insert(root->right, key);    return root;} // Driver program to test above functionsint main(){    node* root = NULL;    root = insert(root, 6);    root = insert(root, -13);    root = insert(root, 14);    root = insert(root, -8);    root = insert(root, 15);    root = insert(root, 13);    root = insert(root, 7);    if (isTripletPresent(root))        printf("Present");    else        printf("Not Present");    return 0;}
// A Java program to check if there// is a triplet with sum equal to 0 in// a given BSTimport java.util.*;class GFG{   // A BST node has key, and left and right pointers  static class node  {    int key;    node left;    node right;  };  static node head;  static node tail;   // A function to convert given BST to Doubly  // Linked List. left pointer is used  // as previous pointer and right pointer  // is used as next pointer. The function  // sets *head to point to first and *tail  // to point to last node of converted DLL  static void convertBSTtoDLL(node root)  {     // Base case    if (root == null)      return;     // First convert the left subtree    if (root.left != null)      convertBSTtoDLL(root.left);     // Then change left of current root    // as last node of left subtree    root.left = tail;     // If tail is not null, then set right    // of tail as root, else current    // node is head    if (tail != null)      (tail).right = root;    else      head = root;     // Update tail    tail = root;     // Finally, convert right subtree    if (root.right != null)      convertBSTtoDLL(root.right);  }   // This function returns true if there  // is pair in DLL with sum equal to given  // sum. The algorithm is similar to hasArrayTwoCandidates()  // in method 1 of http://tinyurl.com/dy6palr  static boolean isPresentInDLL(node head, node tail, int sum)  {    while (head != tail)    {      int curr = head.key + tail.key;      if (curr == sum)        return true;      else if (curr > sum)        tail = tail.left;      else        head = head.right;    }    return false;  }   // The main function that returns  // true if there is a 0 sum triplet in  // BST otherwise returns false  static boolean isTripletPresent(node root)  {    // Check if the given BST is empty    if (root == null)      return false;     // Convert given BST to doubly linked list. head and tail store the    // pointers to first and last nodes in DLLL    head = null;    tail = null;    convertBSTtoDLL(root);     // Now iterate through every node and    // find if there is a pair with sum    // equal to -1 * head.key where head is current node    while ((head.right != tail) && (head.key < 0))    {      // If there is a pair with sum      // equal to -1*head.key, then return      // true else move forward      if (isPresentInDLL(head.right, tail, -1*head.key))        return true;      else        head = head.right;    }     // If we reach here, then    // there was no 0 sum triplet    return false;  }   // A utility function to create  // a new BST node with key as given num  static node newNode(int num)  {    node temp = new node();    temp.key = num;    temp.left = temp.right = null;    return temp;  }   // A utility function to insert a given key to BST  static node insert(node root, int key)  {    if (root == null)      return newNode(key);    if (root.key > key)      root.left = insert(root.left, key);    else      root.right = insert(root.right, key);    return root;  }   // Driver code  public static void main(String[] args)  {    node root = null;    root = insert(root, 6);    root = insert(root, -13);    root = insert(root, 14);    root = insert(root, -8);    root = insert(root, 15);    root = insert(root, 13);    root = insert(root, 7);    if (isTripletPresent(root))      System.out.print("Present");    else      System.out.print("Not Present");  }} // This code is contributed by aashish1995
# A Python program to check if there# is a triplet with sum equal to 0 in# a given BST # A BST Node has key, and left and right pointersclass Node:    def __init__(self):        self.key = 0;        self.left = None;        self.right = None;head = Node();tail = Node(); # A function to convert given BST to Doubly# Linked List. left pointer is used# as previous pointer and right pointer# is used as next pointer. The function# sets *head to point to first and *tail# to point to last Node of converted DLLdef convertBSTtoDLL(root):     # Base case    if (root == None):        return;    global tail;    global head;         # First convert the left subtree    if (root.left != None):        convertBSTtoDLL(root.left);     # Then change left of current root    # as last Node of left subtree    root.left = tail;     # If tail is not None, then set right    # of tail as root, else current    # Node is head    if (tail != None):        (tail).right = root;    else:        head = root;     # Update tail    tail = root;     # Finally, convert right subtree    if (root.right != None):        convertBSTtoDLL(root.right); # This function returns True if there# is pair in DLL with sum equal to given# sum. The algorithm is similar to hasArrayTwoCandidates()# in method 1 of http:#tinyurl.com/dy6palrdef isPresentInDLL(head, tail, s):    while (head != tail):        curr = head.key + tail.key;        if (curr == s):            return True;        elif(curr > s):            tail = tail.left;        else:            head = head.right;         return False; # The main function that returns# True if there is a 0 sum triplet in# BST otherwise returns Falsedef isTripletPresent(root):       # Check if the given BST is empty    if (root == None):        return False;     # Convert given BST to doubly linked list. head and tail store the    # pointers to first and last Nodes in DLLL    global tail;    global head;    head = None;    tail = None;    convertBSTtoDLL(root);     # Now iterate through every Node and    # find if there is a pair with sum    # equal to -1 * head.key where head is current Node    while ((head.right != tail) and (head.key < 0)):               # If there is a pair with sum        # equal to -1*head.key, then return        # True else move forward        if (isPresentInDLL(head.right, tail, -1 * head.key)):            return True;        else:            head = head.right;          # If we reach here, then    # there was no 0 sum triplet    return False; # A utility function to create# a new BST Node with key as given numdef newNode(num):    temp = Node();    temp.key = num;    temp.left = temp.right = None;    return temp; # A utility function to insert a given key to BSTdef insert(root, key):    if (root == None):        return newNode(key);    if (root.key > key):        root.left = insert(root.left, key);    else:        root.right = insert(root.right, key);    return root; # Driver codeif __name__ == '__main__':    root = None;    root = insert(root, 6);    root = insert(root, -13);    root = insert(root, 14);    root = insert(root, -8);    root = insert(root, 15);    root = insert(root, 13);    root = insert(root, 7);    if (isTripletPresent(root)):        print("Present");    else:        print("Not Present"); # This code is contributed by Rajput-Ji
// A C# program to check if there// is a triplet with sum equal to 0 in// a given BSTusing System;public class GFG{   // A BST node has key, and left and right pointers  public class node  {    public int key;    public  node left;    public  node right;  };  static node head;  static node tail;   // A function to convert given BST to Doubly  // Linked List. left pointer is used  // as previous pointer and right pointer  // is used as next pointer. The function  // sets *head to point to first and *tail  // to point to last node of converted DLL  static void convertBSTtoDLL(node root)  {     // Base case    if (root == null)      return;     // First convert the left subtree    if (root.left != null)      convertBSTtoDLL(root.left);     // Then change left of current root    // as last node of left subtree    root.left = tail;     // If tail is not null, then set right    // of tail as root, else current    // node is head    if (tail != null)      (tail).right = root;    else      head = root;     // Update tail    tail = root;     // Finally, convert right subtree    if (root.right != null)      convertBSTtoDLL(root.right);  }   // This function returns true if there  // is pair in DLL with sum equal to given  // sum. The algorithm is similar to hasArrayTwoCandidates()  // in method 1 of http://tinyurl.com/dy6palr  static bool isPresentInDLL(node head, node tail, int sum)  {    while (head != tail)    {      int curr = head.key + tail.key;      if (curr == sum)        return true;      else if (curr > sum)        tail = tail.left;      else        head = head.right;    }    return false;  }   // The main function that returns  // true if there is a 0 sum triplet in  // BST otherwise returns false  static bool isTripletPresent(node root)  {     // Check if the given BST is empty    if (root == null)      return false;     // Convert given BST to doubly linked list. head and tail store the    // pointers to first and last nodes in DLLL    head = null;    tail = null;    convertBSTtoDLL(root);     // Now iterate through every node and    // find if there is a pair with sum    // equal to -1 * head.key where head is current node    while ((head.right != tail) && (head.key < 0))    {      // If there is a pair with sum      // equal to -1*head.key, then return      // true else move forward      if (isPresentInDLL(head.right, tail, -1*head.key))        return true;      else        head = head.right;    }     // If we reach here, then    // there was no 0 sum triplet    return false;  }   // A utility function to create  // a new BST node with key as given num  static node newNode(int num)  {    node temp = new node();    temp.key = num;    temp.left = temp.right = null;    return temp;  }   // A utility function to insert a given key to BST  static node insert(node root, int key)  {    if (root == null)      return newNode(key);    if (root.key > key)      root.left = insert(root.left, key);    else      root.right = insert(root.right, key);    return root;  }   // Driver code  public static void Main(String[] args)  {    node root = null;    root = insert(root, 6);    root = insert(root, -13);    root = insert(root, 14);    root = insert(root, -8);    root = insert(root, 15);    root = insert(root, 13);    root = insert(root, 7);    if (isTripletPresent(root))      Console.Write("Present");    else      Console.Write("Not Present");  }} // This code is contributed by aashish1995
<script> // A JavaScript program to check if there// is a triplet with sum equal to 0 in// a given BST     // A BST node has key,    // and left and right pointers     class node {        constructor(val) {            this.key = val;            this.left = null;            this.right = null;        }    }       var head;     var tail;     // A function to convert given BST to Doubly    // Linked List. left pointer is used    // as previous pointer and right pointer    // is used as next pointer. The function    // sets *head to point to first and *tail    // to point to last node of converted DLL    function convertBSTtoDLL( root) {         // Base case        if (root == null)            return;         // First convert the left subtree        if (root.left != null)            convertBSTtoDLL(root.left);         // Then change left of current root        // as last node of left subtree        root.left = tail;         // If tail is not null, then set right        // of tail as root, else current        // node is head        if (tail != null)            (tail).right = root;        else            head = root;         // Update tail        tail = root;         // Finally, convert right subtree        if (root.right != null)            convertBSTtoDLL(root.right);    }     // This function returns true if there    // is pair in DLL with sum equal to given    // sum. The algorithm is    // similar to hasArrayTwoCandidates()    // in method 1 of http://tinyurl.com/dy6palr    function isPresentInDLL( head,  tail , sum) {        while (head != tail) {            var curr = head.key + tail.key;            if (curr == sum)                return true;            else if (curr > sum)                tail = tail.left;            else                head = head.right;        }        return false;    }     // The main function that returns    // true if there is a 0 sum triplet in    // BST otherwise returns false    function isTripletPresent( root) {        // Check if the given BST is empty        if (root == null)            return false;         // Convert given BST to doubly        // linked list. head and tail store the        // pointers to first and last nodes in DLLL        head = null;        tail = null;        convertBSTtoDLL(root);         // Now iterate through every node and        // find if there is a pair with sum        // equal to -1 * head.key where        // head is current node        while ((head.right != tail) && (head.key < 0))        {            // If there is a pair with sum            // equal to -1*head.key, then return            // true else move forward            if (isPresentInDLL(head.right, tail,            -1 * head.key))                return true;            else                head = head.right;        }         // If we reach here, then        // there was no 0 sum triplet        return false;    }     // A utility function to create    // a new BST node with key as given num     function newNode(num) {        var temp = new node();        temp.key = num;        temp.left = temp.right = null;        return temp;    }     // A utility function to insert a given key to BST     function insert( root , key) {        if (root == null)            return newNode(key);        if (root.key > key)            root.left = insert(root.left, key);        else            root.right = insert(root.right, key);        return root;    }     // Driver code             var root = null;        root = insert(root, 6);        root = insert(root, -13);        root = insert(root, 14);        root = insert(root, -8);        root = insert(root, 15);        root = insert(root, 13);        root = insert(root, 7);        if (isTripletPresent(root))            document.write("Present");        else            document.write("Not Present"); // This code contributed by gauravrajput1 </script>
Present
Note that the above solution modifies given BST.
Time Complexity: Time taken to convert BST to DLL is O(n) and time taken to find triplet in DLL is O(n^2).Auxiliary Space: The auxiliary space is needed only for function call stack in recursive function convertBSTtoDLL(). Since given tree is balanced (height is O(Logn)), the number of functions in call stack will never be more than O(Logn).
We can also find triplet in same time and extra space without modifying the tree. See next post. The code discussed there can be used to find triplet also.
rathbhupendra
aashish1995
GauravRajput1
simranarora5sos
Rajput-Ji
surinderdawra388
simmytarika5
hardikkoriintern
Binary Search Tree
Binary Search Tree
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
set vs unordered_set in C++ STL
Flatten BST to sorted list | Increasing order
Largest BST in a Binary Tree | Set 2
Find median of BST in O(n) time and O(1) space
Given n appointments, find all conflicting appointments
Replace every element with the least greater element on its right
Convert BST to Min Heap
Floor and Ceil from a BST
Count BST nodes that lie in a given range
Common operations on various Data Structures