Given a binary search tree, and an integer X, the task is to find if there exists a triplet with sum X. Print Yes or No correspondingly. Note that the three nodes may not necessarily be distinct.
Examples:
Input: X = 15
5
/ \
3 7
/ \ / \
2 4 6 8
Output: Yes
{5, 5, 5} is one such triplet.
{3, 5, 7}, {2, 5, 8}, {4, 5, 6} are some others.
Input: X = 16
1
\
2
\
3
\
4
\
5
Output: No
Simple Approach: A simple approach will be to convert the BST to a sorted array and then find the triplet using three-pointers. This will take O(N) extra space where N is the number of nodes present in the Binary Search Tree. We have already discussed a similar problem in this article which takes O(N) extra space.
Better approach: We will solve this problem using a space-efficient method by reducing the additional space complexity to O(H) where H is the height of BST. For that, we will use the two pointer technique on BST.
We will traverse all the nodes for the tree one by one and for each node, we will try to find a pair with a sum equal to (X – curr->data) where ‘curr’ is the current node of the BST we are traversing.
We will use a technique similar to the technique discussed in this article for finding a pair.
Algorithm: Traverse each node of BST one by one and for each node:
- Create a forward and backward iterator for BST. Let’s say the value of nodes they are pointing at are v1 and v2.
- Now at each step,
- If v1 + v2 = X, we found a pair, thus we will increase the count by 1.
- If v1 + v2 less than or equal to x, we will make forward iterator point to the next element.
- If v1 + v2 greater than x, we will make backward iterator point to the previous element.
- We will continue the above while the left iterator doesn’t point to a node with larger value than right node.
Below is the implementation of the above approach:
C++
// C++ implementation of the approach#include <bits/stdc++.h>using namespace std;// Node of the binary treestruct node { int data; node* left; node* right; node(int data) { this->data = data; left = NULL; right = NULL; }};// Function that returns true if a pair exists// in the binary search tree with sum equal to xbool existsPair(node* root, int x){ // Iterators for BST stack<node *> it1, it2; // Initializing forward iterator node* c = root; while (c != NULL) it1.push(c), c = c->left; // Initializing backward iterator c = root; while (c != NULL) it2.push(c), c = c->right; // Two pointer technique while (it1.size() and it2.size()) { // Variables to store values at // it1 and it2 int v1 = it1.top()->data, v2 = it2.top()->data; // Base case if (v1 + v2 == x) return 1; if (v1 > v2) break; // Moving forward pointer if (v1 + v2 < x) { c = it1.top()->right; it1.pop(); while (c != NULL) it1.push(c), c = c->left; } // Moving backward pointer else { c = it2.top()->left; it2.pop(); while (c != NULL) it2.push(c), c = c->right; } } // Case when no pair is found return 0;}// Function that returns true if a triplet exists// in the binary search tree with sum equal to xbool existsTriplet(node* root, node* curr, int x){ // If current node is NULL if (curr == NULL) return 0; // Conditions for existence of a triplet return (existsPair(root, x - curr->data) || existsTriplet(root, curr->left, x) || existsTriplet(root, curr->right, x));}// Driver codeint main(){ node* root = new node(5); root->left = new node(3); root->right = new node(7); root->left->left = new node(2); root->left->right = new node(4); root->right->left = new node(6); root->right->right = new node(8); int x = 24; if (existsTriplet(root, root, x)) cout << "Yes"; else cout << "No"; return 0;} |
Java
// Java implementation of the approachimport java.io.*;import java.util.*;// Node of the binary treeclass Node{ int data; Node left, right; Node(int item) { data = item; left = right = null; }}class GFG{ static Node root; // Function that returns true if a pair exists // in the binary search tree with sum equal to x static boolean existsPair(Node root, int x) { // Iterators for BST Stack<Node> it1 = new Stack<Node>(); Stack<Node> it2 = new Stack<Node>(); // Initializing forward iterator Node c = root; while (c != null) { it1.push(c); c = c.left; } // Initializing backward iterator c = root; while (c != null) { it2.push(c); c = c.right; } // Two pointer technique while (it1.size() > 0 && it2.size() > 0) { // Variables to store values at // it1 and it2 int v1 = it1.peek().data; int v2 = it2.peek().data; // Base case if (v1 + v2 == x) { return true; } if (v1 > v2) { break; } // Moving forward pointer if (v1 + v2 < x) { c = it1.peek().right; it1.pop(); while (c != null) { it1.push(c); c = c.left; } } // Moving backward pointer else { c = it2.peek().left; it2.pop(); while(c != null) { it2.push(c); c = c.right; } } } // Case when no pair is found return false; } // Function that returns true if a triplet exists // in the binary search tree with sum equal to x static boolean existsTriplet(Node root, Node curr, int x ) { // If current node is NULL if(curr == null) { return false; } // Conditions for existence of a triplet return (existsPair(root, x - curr.data) || existsTriplet(root, curr.left, x) || existsTriplet(root, curr.right, x)); } // Driver code public static void main (String[] args) { GFG tree = new GFG(); tree.root = new Node(5); tree.root.left = new Node(3); tree.root.right = new Node(7); tree.root.left.left = new Node(2); tree.root.left.right = new Node(4); tree.root.right.left = new Node(6); tree.root.right.right = new Node(8); int x = 24; if (existsTriplet(root, root, x)) { System.out.println("Yes"); } else { System.out.println("No"); } }}// This code is contributed by avanitrachhadiya2155 |
Python3
# Python3 implementation of the approachclass Node: def __init__(self, x): self.data = x self.left = None self.right = None# Function that returns true if a pair exists# in the binary search tree with sum equal to xdef existsPair(root, x): # Iterators for BST it1, it2 = [], [] # Initializing forward iterator c = root while (c != None): it1.append(c) c = c.left # Initializing backward iterator c = root while (c != None): it2.append(c) c = c.right # Two pointer technique while (len(it1) > 0 and len(it2) > 0): # Variables to store values at # it1 and it2 v1 = it1[-1].data v2 = it2[-1].data # Base case if (v1 + v2 == x): return 1 if (v1 > v2): break # Moving forward pointer if (v1 + v2 < x): c = it1[-1].right del it1[-1] while (c != None): it1.append(c) c = c.left # Moving backward pointer else: c = it2[-1].left del it2[-1] while (c != None): it2.append(c) c = c.right # Case when no pair is found return 0# Function that returns true if a triplet exists# in the binary search tree with sum equal to xdef existsTriplet(root, curr, x): # If current node is NULL if (curr == None): return 0 # Conditions for existence of a triplet return (existsPair(root, x - curr.data) or existsTriplet(root, curr.left, x) or existsTriplet(root, curr.right, x))# Driver codeif __name__ == '__main__': root = Node(5) root.left = Node(3) root.right = Node(7) root.left.left = Node(2) root.left.right = Node(4) root.right.left = Node(6) root.right.right = Node(8) x = 24 if (existsTriplet(root, root, x)): print("Yes") else: print("No")# This code is contributed by mohit kumar 29 |
C#
// C# implementation of the approachusing System;using System.Collections.Generic;// Node of the binary treeclass Node{ public int data; public Node left, right; public Node(int item) { data = item; left = right = null; }}class GFG{ static Node root;// Function that returns true if a pair exists// in the binary search tree with sum equal to xstatic bool existsPair(Node root, int x){ // Iterators for BST Stack<Node> it1 = new Stack<Node>(); Stack<Node> it2 = new Stack<Node>(); // Initializing forward iterator Node c = root; while (c != null) { it1.Push(c); c = c.left; } // Initializing backward iterator c = root; while (c != null) { it2.Push(c); c = c.right; } // Two pointer technique while (it1.Count > 0 && it2.Count > 0) { // Variables to store values at // it1 and it2 int v1 = it1.Peek().data; int v2 = it2.Peek().data; // Base case if (v1 + v2 == x) { return true; } if (v1 > v2) { break; } // Moving forward pointer if (v1 + v2 < x) { c = it1.Peek().right; it1.Pop(); while (c != null) { it1.Push(c); c = c.left; } } // Moving backward pointer else { c = it2.Peek().left; it2.Pop(); while(c != null) { it2.Push(c); c = c.right; } } } // Case when no pair is found return false;}// Function that returns true if a triplet exists// in the binary search tree with sum equal to xstatic bool existsTriplet(Node root, Node curr, int x){ // If current node is NULL if (curr == null) { return false; } // Conditions for existence of a triplet return (existsPair(root, x - curr.data) || existsTriplet(root, curr.left, x) || existsTriplet(root, curr.right, x));}// Driver codestatic public void Main(){ GFG.root = new Node(5); GFG.root.left = new Node(3); GFG.root.right = new Node(7); GFG.root.left.left = new Node(2); GFG.root.left.right = new Node(4); GFG.root.right.left = new Node(6); GFG.root.right.right = new Node(8); int x = 24; if (existsTriplet(root, root, x)) { Console.WriteLine("Yes"); } else { Console.WriteLine("No"); }}}// This code is contributed by rag2127 |
Javascript
<script>// Javascript implementation of the approach// Node of the binary treeclass node{ constructor(data) { this.data = data; this.left = this.right = null; }}// Function to find a pair with given sumfunction existsPair(root, x){ // Iterators for BST let it1 = [], it2 = []; // Initializing forward iterator let c = root; while (c != null) { it1.push(c); c = c.left; } // Initializing backward iterator c = root; while (c != null) { it2.push(c); c = c.right; } // Two pointer technique while (it1.length > 0 && it2.length > 0) { // Variables to store values at // it1 and it2 let v1 = it1[it1.length - 1].data, v2 = it2[it2.length - 1].data; // Base case if (v1 + v2 == x) return true; if (v1 > v2) { break; } // Moving forward pointer if (v1 + v2 < x) { c = it1[it1.length - 1].right; it1.pop(); while (c != null) { it1.push(c); c = c.left; } } // Moving backward pointer else { c = it2[it2.length - 1].left; it2.pop(); while (c != null) { it2.push(c); c = c.right; } } } // Case when no pair is found return false;}// Function that returns true if a // triplet exists in the binary // search tree with sum equal to xfunction existsTriplet(root, curr, x){ // If current node is NULL if (curr == null) { return false; } // Conditions for existence of a triplet return (existsPair(root, x - curr.data) || existsTriplet(root, curr.left, x) || existsTriplet(root, curr.right, x));}// Driver codelet root = new node(5);root.left = new node(3);root.right = new node(7);root.left.left = new node(2);root.left.right = new node(4);root.right.left = new node(6);root.right.right = new node(8);let x = 24;// Calling required functionif (existsTriplet(root, root, x)) document.write("Yes");else document.write("No");// This code is contributed by unknown2108</script> |
Output:
Yes
Time complexity: O(N2)
Space complexity: O(H), since H extra space has been taken.
Feeling lost in the world of random DSA topics, wasting time without progress? It’s time for a change! Join our DSA course, where we’ll guide you on an exciting journey to master DSA efficiently and on schedule.
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 neveropen!
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 neveropen!
