Given a binary search tree and a sorted sub-sequence. the task is to check if the given sorted sub-sequence exist in binary search tree or not.
Examples:
// For above binary search tree
Input : seq[] = {4, 6, 8, 14}
Output: "Yes"
Input : seq[] = {4, 6, 8, 12, 13}
Output: "No"
A simple solution is to store inorder traversal in an auxiliary array and then by matching elements of sorted sub-sequence one by one with inorder traversal of tree , we can if sub-sequence exist in BST or not. Time complexity for this approach will be O(n) but it requires extra space O(n) for storing traversal in an array.
An efficient solution is to match elements of sub-sequence while we are traversing BST in inorder fashion. We take index as a iterator for given sorted sub-sequence and start inorder traversal of given bst, if current node matches with seq[index] then move index in forward direction by incrementing 1 and after complete traversal of BST if index==n that means all elements of given sub-sequence have been matched and exist as a sorted sub-sequence in given BST.
C++
// C++ program to find if given array exists as a // subsequece in BST #include<bits/stdc++.h> using namespace std; // A binary Tree node struct Node { int data; struct Node *left, *right; }; // A utility function to create a new BST node // with key as given num struct Node* newNode(int num) { struct Node* temp = new Node; temp->data = num; temp->left = temp->right = NULL; return temp; } // A utility function to insert a given key to BST struct Node* insert(struct Node* root, int key) { if (root == NULL) return newNode(key); if (root->data > key) root->left = insert(root->left, key); else root->right = insert(root->right, key); return root; } // function to check if given sorted sub-sequence exist in BST // index --> iterator for given sorted sub-sequence // seq[] --> given sorted sub-sequence void seqExistUtil(struct Node *ptr, int seq[], int &index) { if (ptr == NULL) return; // We traverse left subtree first in Inorder seqExistUtil(ptr->left, seq, index); // If current node matches with se[index] then move // forward in sub-sequence if (ptr->data == seq[index]) index++; // We traverse left subtree in the end in Inorder seqExistUtil(ptr->right, seq, index); } // A wrapper over seqExistUtil. It returns true // if seq[0..n-1] exists in tree. bool seqExist(struct Node *root, int seq[], int n) { // Initialize index in seq[] int index = 0; // Do an inorder traversal and find if all // elements of seq[] were present seqExistUtil(root, seq, index); // index would become n if all elements of // seq[] were present return (index == n); } // driver program to run the case int main() { struct Node* root = NULL; root = insert(root, 8); root = insert(root, 10); root = insert(root, 3); root = insert(root, 6); root = insert(root, 1); root = insert(root, 4); root = insert(root, 7); root = insert(root, 14); root = insert(root, 13); int seq[] = {4, 6, 8, 14}; int n = sizeof(seq)/sizeof(seq[0]); seqExist(root, seq, n)? cout << "Yes" : cout << "No"; return 0; } |
chevron_right
filter_none
Java
// Java program to find if given array // exists as a subsequece in BST import java.util.*; class GFG { // A binary Tree node static class Node { int data; Node left, right; }; //structure of int class static class INT { int a; } // A utility function to create a new BST node // with key as given num static Node newNode(int num) { Node temp = new Node(); temp.data = 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.data > key) root.left = insert(root.left, key); else root.right = insert(root.right, key); return root; } // function to check if given sorted // sub-sequence exist in BST index -. // iterator for given sorted sub-sequence // seq[] -. given sorted sub-sequence static void seqExistUtil( Node ptr, int seq[], INT index) { if (ptr == null) return; // We traverse left subtree // first in Inorder seqExistUtil(ptr.left, seq, index); // If current node matches // with se[index] then move // forward in sub-sequence if (ptr.data == seq[index.a]) index.a++; // We traverse left subtree // in the end in Inorder seqExistUtil(ptr.right, seq, index); } // A wrapper over seqExistUtil. // It returns true if seq[0..n-1] // exists in tree. static boolean seqExist( Node root, int seq[], int n) { // Initialize index in seq[] INT index = new INT(); index.a = 0; // Do an inorder traversal and find if all // elements of seq[] were present seqExistUtil(root, seq, index); // index would become n if all // elements of seq[] were present return (index.a == n); } // Driver code public static void main(String args[]) { Node root = null; root = insert(root, 8); root = insert(root, 10); root = insert(root, 3); root = insert(root, 6); root = insert(root, 1); root = insert(root, 4); root = insert(root, 7); root = insert(root, 14); root = insert(root, 13); int seq[] = {4, 6, 8, 14}; int n = seq.length; if(seqExist(root, seq, n)) System.out.println("Yes"); else System.out.println("No"); } } // This code is contributed by Arnab Kundu |
chevron_right
filter_none
Python3
# Python3 program to find if given array # exists as a subsequece in BST class Node: # Constructor to create a new node def __init__(self, data): self.data = data self.left = None self.right = None # A utility function to insert a # given key to BST def insert(root, key): if root == None: return Node(key) if root.data > key: root.left = insert(root.left, key) else: root.right = insert(root.right, key) return root # function to check if given sorted # sub-sequence exist in BST index . # iterator for given sorted sub-sequence # seq[] . given sorted sub-sequence def seqExistUtil(ptr, seq, index): if ptr == None: return # We traverse left subtree # first in Inorder seqExistUtil(ptr.left, seq, index) # If current node matches with se[index[0]] # then move forward in sub-sequence if ptr.data == seq[index[0]]: index[0] += 1 # We traverse left subtree in # the end in Inorder seqExistUtil(ptr.right, seq, index) # A wrapper over seqExistUtil. It returns # true if seq[0..n-1] exists in tree. def seqExist(root, seq, n): # Initialize index in seq[] index = [0] # Do an inorder traversal and find if # all elements of seq[] were present seqExistUtil(root, seq, index) # index would become n if all elements # of seq[] were present if index[0] == n: return True else: return False # Driver Code if __name__ == '__main__': root = None root = insert(root, 8) root = insert(root, 10) root = insert(root, 3) root = insert(root, 6) root = insert(root, 1) root = insert(root, 4) root = insert(root, 7) root = insert(root, 14) root = insert(root, 13) seq = [4, 6, 8, 14] n = len(seq) if seqExist(root, seq, n): print("Yes") else: print("No") # This code is contributed by PranchalK |
chevron_right
filter_none
C#
// C# program to find if given array // exists as a subsequece in BST using System; class GFG { // A binary Tree node public class Node { public int data; public Node left, right; }; // structure of int class public class INT { public int a; } // A utility function to create a new BST node // with key as given num static Node newNode(int num) { Node temp = new Node(); temp.data = 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.data > key) root.left = insert(root.left, key); else root.right = insert(root.right, key); return root; } // function to check if given sorted // sub-sequence exist in BST index -. // iterator for given sorted sub-sequence // seq[] -. given sorted sub-sequence static void seqExistUtil( Node ptr, int []seq, INT index) { if (ptr == null) return; // We traverse left subtree // first in Inorder seqExistUtil(ptr.left, seq, index); // If current node matches // with se[index] then move // forward in sub-sequence if (ptr.data == seq[index.a]) index.a++; // We traverse left subtree // in the end in Inorder seqExistUtil(ptr.right, seq, index); } // A wrapper over seqExistUtil. // It returns true if seq[0..n-1] // exists in tree. static bool seqExist( Node root, int []seq, int n) { // Initialize index in seq[] INT index = new INT(); index.a = 0; // Do an inorder traversal and find if all // elements of seq[] were present seqExistUtil(root, seq, index); // index would become n if all // elements of seq[] were present return (index.a == n); } // Driver code public static void Main(String []args) { Node root = null; root = insert(root, 8); root = insert(root, 10); root = insert(root, 3); root = insert(root, 6); root = insert(root, 1); root = insert(root, 4); root = insert(root, 7); root = insert(root, 14); root = insert(root, 13); int []seq = {4, 6, 8, 14}; int n = seq.Length; if(seqExist(root, seq, n)) Console.WriteLine("Yes"); else Console.WriteLine("No"); } } /* This code contributed by PrinciRaj1992 */ |
chevron_right
filter_none
Output:
Yes
Time complexity: O(n)
This article is contributed by Shashank Mishra ( Gullu ). If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.
Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.
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.
Recommended Posts:
- Binary Tree to Binary Search Tree Conversion
- Binary Tree to Binary Search Tree Conversion using STL set
- Difference between Binary Tree and Binary Search Tree
- Binary Search Tree | Set 1 (Search and Insertion)
- Check whether a subsequence exists with sum equal to k if arr[i]> 2*arr[i-1]
- Check if a subsequence of length K with odd sum exists
- Check if a given array can represent Preorder Traversal of Binary Search Tree
- Convert a Binary Search Tree into a Skewed tree in increasing or decreasing order
- Count the Number of Binary Search Trees present in a Binary Tree
- Check if an array represents Inorder of Binary Search tree or not
- Construct a Binary Search Tree from given postorder
- Number of pairs with a given sum in a Binary Search Tree
- Maximum height of the binary search tree created from the given array
- Count permutations of given array that generates the same Binary Search Tree (BST)
- Check if a given Binary Tree is height balanced like a Red-Black Tree
- Maximum sub-tree sum in a Binary Tree such that the sub-tree is also a BST
- Longest subsequence such that every element in the subsequence is formed by multiplying previous element with a prime
- Find the equal pairs of subsequence of S and subsequence of T
- Find the node with minimum value in a Binary Search Tree
- Lowest Common Ancestor in a Binary Search Tree.
