Find if there is a triplet in a balanced bst that adds to zero

Problem Statement:

Given a balanced (height balanced) binary search tree and the task is to find whether there exists a triplet (3 elements) that sum up to 0 and if present return present else not present

Input:

	
		6
      /   \
  -13        14
	 \	    /  \
    -8     13   15
                /
               7

Output:

{-13,  6, 7}

The straightforward approach involves examining every triplet within the Binary Search Tree (BST) and verifying whether the sum equals zero. This method carries a time complexity of O(n^3).

An improved strategy entails generating an auxiliary array to store the Inorder traversal of the Binary Search Tree (BST). This array is guaranteed to be sorted, as the Inorder traversal of a BST consistently yields data in sorted order.

Better version

The provided solution operates in O(n^2) time complexity and utilizes O(Logn) additional space:

Transform the given Binary Search Tree (BST) into a Doubly Linked List (DLL).
Iterate through each node of the DLL. If the node's key is negative, search for a pair within the DLL whose sum equals the key of the current node multiplied by -1.

Java Implementation:

import java.util.*;
class BSTTriplets {
    // Definition for a Binary Search Tree (BST) node
    static class TreeNode {
intvalue;          // Value of the node
TreeNodeleft;      // Reference to the left child node
TreeNoderight;     // Reference to the right child node
    };

    static TreeNodehead;   // Head of the doubly linked list
    static TreeNodetail;   // Tail of the doubly linked list
    // Function to convert a Binary Search Tree (BST) to a Doubly Linked List (DLL)
    static void convertBSTtoDLL(TreeNode root) {
        // Base case: If the root is null, return
        if (root == null)
            return;
        // Recursively convert the left subtree
        if (root.left != null)
convertBSTtoDLL(root.left);
        // Set the left pointer of the current root to the current tail
root.left = tail;
        // If tail is not null, set the right pointer of tail to the current root,
        // else set the head to the current root
        if (tail != null)
            (tail).right = root;
        else
            head = root;
        // Update tail to the current root
        tail = root;
        // Recursively convert the right subtree
        if (root.right != null)
convertBSTtoDLL(root.right);
    }
    // Function to check if a given sum exists in the DLL
    static booleanisPresentInDLL(TreeNode head, TreeNode tail, int sum) {
        // Iterate through the DLL from both ends until head meets tail
        while (head != tail) {
int curr = head.value + tail.value;
            // If the sum is found, return true
            if (curr == sum)
                return true;
            // If the current sum is greater than the target, move tail to the left
            else if (curr > sum)
                tail = tail.left;
            // If the current sum is less than the target, move head to the right
            else
                head = head.right;
        }
        // If the sum is not found, return false
        return false;
    }
    // Function to check if there exists a triplet with sum equal to 0 in the BST
    static booleanisTripletPresent(TreeNode root) {
        // Check if the given BST is empty
        if (root == null)
            return false;
        // Initialize head and tail to null
        head = null;
        tail = null;
        // Convert the given BST to a doubly linked list
convertBSTtoDLL(root);
        // Iterate through the DLL and find a triplet with a sum of 0
        while ((head.right != tail) && (head.value< 0)) {
            // If a triplet is found, return true
            if (isPresentInDLL(head.right, tail, -1 * head.value))
                return true;
            // Move head to the right for the next iteration
            else
                head = head.right;
        }

        // If no triplet with a sum of 0 is found, return false
        return false;
    }
    // Function to create a new node with the given value
    static TreeNodecreateNewNode(intnum) {
TreeNode temp = new TreeNode();
temp.value = num;
temp.left = temp.right = null;
        return temp;
    }
    // Function to insert a value into the BST
    static TreeNodeinsert(TreeNode root, int value) {
        // If the root is null, create a new node with the given value
        if (root == null)
            return createNewNode(value);
        // If the value is less than the root's value, insert into the left subtree
        if (root.value> value)
root.left = insert(root.left, value);
        // If the value is greater than or equal to the root's value, insert into the right subtree
        else
root.right = insert(root.right, value);
        // Return the modified root
        return root;
    }
    // Main driver code
    public static void main(String[] args) {
TreeNode root = null;

        // Insert values into the BST
        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);
        // Check and print whether a triplet with sum 0 is present in the BST
        if (isTripletPresent(root))
System.out.print("Present");
        else
System.out.print("Not Present");
    }
}

Output: