Professional Documents
Culture Documents
BST-2
Q1. Binary Tree is BST or not
Input: Given a binary search tree (BST) i.e. a node-based binary tree data structure that has the following
properties
The left subtree of a node contains only nodes with keys less than the node’s key
The right subtree of a node contains only nodes with keys greater than the node’s key
Both the left and right subtrees must also be binary search trees
Each node (item in the tree) has a distinct key.
Given Tree:
Output:
Explanation
We are following the given approach
If the current node is null then return tru
If the value of the left child of the node is greater than or equal to the current node then return fals
If the value of the right child of the node is less than or equal to the current node then return fals
If the left subtree or the right subtree is not a BST then return fals
Else return true
Time complexity: O(n), where n is the number of nodes in the binary tree. This is because the code traverses
each node exactly once in a depth-first manner. In the worst case, when the binary tree is a valid BST, every
node needs to be visited to validate the BST property.
Space complexity: O(h), where h is the height of the binary tree. This is because the code utilizes the call stack
during the recursive function calls, which depends on the height of the tree. In the worst case, when the tree is
skewed, the height is equal to the number of nodes, resulting in O(n) space complexity. However, in a balanced
binary tree, the height is logarithmic to the number of nodes, resulting in O(log n) space complexity.
Input:
Given two vectors that represent a sequence of keys. Imagine we make a Binary Search Tree (BST) from each
arr2 = {4, 5, 2, 3, 1}
Output:
Explanation
According to the BST property, elements of the left subtree must be smaller and elements of right subtree
must be greater than root.
Two arrays represent the same BST if, for every element x, the elements in left and right subtrees of x appear
after it in both arrays. And same is true for roots of left and right subtrees.
The idea is to check of if next smaller and greater elements are same in both arrays. Same properties are
recursively checked for left and right subtrees. The idea looks simple, but implementation requires checking
all conditions for all elements.
Time complexity: O(n^2), where n is the number of elements in the arrays representing the BSTs. This is
because for each element in one array, we search for a corresponding element in the other array, resulting in a
nested loop structure. In the worst case, we may need to iterate over all elements in both arrays.
Space complexity: O(1) because we are not using any additional data structures that grow with the input size.
We only use a few integer variables to keep track of indices and values during the recursive calls. Thus, the
space required remains constant regardless of the input size.
Input: Given the preorder traversal of a binary search tree, construct the BST.
Output:
NOTE : For building a tree any two traversals must be known. In case of BST, preorder is given and we know
inorder traversal of bst is just the sorted preorder array
The first element of preorder traversal is always the root.
We first construct the root.
Then we find the index of the first element which is greater than the root.
Let the index be ‘i’.
The values between root and ‘i’ will be part of the left subtree, and the values between ‘i'(inclusive) and ‘n-1’
will be part of the right subtree.
Divide the given pre[] at index “i” and recur for left and right sub-trees.
Time complexity: O(n), where n is the number of elements in the traversal. This is because we visit each
element once and perform constant-time operations for each node.
Space complexity: O(n) as well, considering the space required for the recursive function calls on the call
stack. In the worst-case scenario, the function calls will be nested to the depth of the tree, which is proportional
to the number of nodes, resulting in O(n) space complexity. Additionally, the space complexity also includes
the space required to store the BST itself, which is also O(n) in the worst case.
Input: Given a Binary Search Tree with unique value of nodes and two keys in it. Find the distance between two
nodes with given two keys. It may be assumed that both keys exist in BST.
Given BST:
Output:
Explanation
If both keys are greater than the current node, we move to the right child of the current node
If both keys are smaller than current node, we move to left child of current node
If one keys is smaller and other key is greater, current node is Lowest Common Ancestor (LCA) of two nodes.
We find distances of current node from two keys and return sum of the distances.
Input: Given a Binary Tree, write a function that returns the size of the largest subtree which is also a Binary
Search Tree (BST). If the complete Binary Tree is BST, then return the size of the whole tree.
Output:
BST:
Explanation:
Here, we don’t need to check explicitly if the binary tree is BST. A Tree is BST if the following is true for every node
x
The largest value in the left subtree (of x) is smaller than the value of x
The smallest value in the right subtree (of x) is greater than the value of x.
So, we will just check if the largest value of the left subtree is less than the value of the root node and the
Time complexity: O(N), where N is the number of nodes in the binary tree. This is because we visit each node
once during the recursive traversal to determine the largest BST subtree.
Space complexity: O(N) as well. This is due to the recursive nature of the algorithm, which involves maintaining
recursive function calls on the call stack. In the worst case scenario, where the binary tree is skewed, the
maximum space required on the call stack is proportional to the number of nodes in the tree.
Input: Write a C++ program to construct all unique binary search trees (BSTs) for keys ranging from 1 to N. The
program should prompt the user to enter the value of N, and then construct and display all possible BSTs for
the given range of keys.
Given N = 4
Output:
Explanation
Initialize list of BSTs as empty.
For every number i where i varies from 1 to N, do followin
Create a new node with key as ‘i’, let this node be ‘node
Recursively construct a list of all left subtrees
Recursively construct a list of all right subtrees.
Iterate for all left subtree
For current left subtree, iterate for all right subtree
Add current left and right subtrees to ‘node’ and add
node’ to list
Time complexity: O(2^n) This is because we are constructing all possible BSTs. Since at each level, we are
generating two subproblems and at each level, there are O(2^n) subproblems, the time complexity is O(2^n).
Input: Given an array of integers, replace every element with the least greater element on its right side in the
array. If there are no greater elements on the right side, replace it with -1.
Output:
Explanation:
The approach used in the solution can be summarized in the following steps
1Start from the rightmost element of the array and initialize an empty Binary Search Tree (BST)
Iterate through the array from right to left and insert each element into the BST
During the insertion process, keep track of the successor for each element (the least greater element on its
right side)
If a successor is found, replace the current element with the successor value
If no successor is found (reached the end of the BST), replace the current element with -1
Repeat steps 2-5 for all elements in the array
Print the updated array after all replacements have been made.
This approach ensures that for each element, we find the least greater element on its right side by utilizing the
properties of the Binary Search Tree.
The time complexity is O(nlogn) because we perform insertions and lookups in the Binary Search Tree (BST) for
each element in the array.
The space complexity is O(n) because we store the elements in the BST, which can have up to n nodes in the
worst case.