Given a Binary search Tree that contains positive integer values greater than 0. The task is to check whether the BST contains a dead end or not. Here Dead End means, we are not able to insert any element after that node.
Examples:
Input : 8
/ \
5 9
/ \
2 7
/
1
Output : Yes
Explanation : Node "1" is the dead End because
after that we cant insert any element.
Input : 8
/ \
7 10
/ / \
2 9 13
Output : Yes
Explanation : We can't insert any element at
node 9.
If we take a closer look at the problem, we can notice that we basically need to check if there is a leaf node with value x such that x+1 and x-1 exist in BST with the exception of x = 1. For x = 1, we can’t insert 0 as the problem statement says BST contains positive integers only.
To implement the above idea we first traverse the whole BST and store all nodes in a hash_map. We also store all leaves in a separate hash to avoid re-traversal of BST. Finally, we check for every leaf node x, if x-1 and x+1 are present in hash_map or not.
Below is a C++ implementation of the above idea.
C++
// C++ program check weather BST contains// dead end or not#include<bits/stdc++.h>using namespace std;// A BST nodestruct Node{ int data; struct Node *left, *right;};// A utility function to create a new nodeNode *newNode(int data){ Node *temp = new Node; temp->data = data; temp->left = temp->right = NULL; return temp;}/* A utility function to insert a new Node with given key in BST */struct Node* insert(struct Node* node, int key){ /* If the tree is empty, return a new Node */ if (node == NULL) return newNode(key); /* Otherwise, recur down the tree */ if (key < node->data) node->left = insert(node->left, key); else if (key > node->data) node->right = insert(node->right, key); /* return the (unchanged) Node pointer */ return node;}// Function to store all node of given binary search treevoid storeNodes(Node * root, unordered_set<int> &all_nodes, unordered_set<int> &leaf_nodes){ if (root == NULL) return ; // store all node of binary search tree all_nodes.insert(root->data); // store leaf node in leaf_hash if (root->left==NULL && root->right==NULL) { leaf_nodes.insert(root->data); return ; } // recur call rest tree storeNodes(root-> left, all_nodes, leaf_nodes); storeNodes(root->right, all_nodes, leaf_nodes);}// Returns true if there is a dead end in tree,// else false.bool isDeadEnd(Node *root){ // Base case if (root == NULL) return false ; // create two empty hash sets that store all // BST elements and leaf nodes respectively. unordered_set<int> all_nodes, leaf_nodes; // insert 0 in 'all_nodes' for handle case // if bst contain value 1 all_nodes.insert(0); // Call storeNodes function to store all BST Node storeNodes(root, all_nodes, leaf_nodes); // Traversal leaf node and check Tree contain // continuous sequence of // size tree or Not for (auto i = leaf_nodes.begin() ; i != leaf_nodes.end(); i++) { int x = (*i); // Here we check first and last element of // continuous sequence that are x-1 & x+1 if (all_nodes.find(x+1) != all_nodes.end() && all_nodes.find(x-1) != all_nodes.end()) return true; } return false ;}// Driver programint main(){/* 8 / \ 5 11 / \ 2 7 \ 3 \ 4 */ Node *root = NULL; root = insert(root, 8); root = insert(root, 5); root = insert(root, 2); root = insert(root, 3); root = insert(root, 7); root = insert(root, 11); root = insert(root, 4); if (isDeadEnd(root) == true) cout << "Yes " << endl; else cout << "No " << endl; return 0;} |
Python3
# Python 3 program check # weather BST contains# dead end or notall_nodes = set()leaf_nodes = set()# A BST nodeclass newNode: def __init__(self, data): self.data = data self.left = None self.right = None''' A utility function to insert a new Node with given key in BST '''def insert(node, key): '''/* If the tree is empty, return a new Node */ ''' if (node == None): return newNode(key) # Otherwise, recur down # the tree if (key < node.data): node.left = insert(node.left, key) elif (key > node.data): node.right = insert(node.right, key) # return the (unchanged) # Node pointer return node# Function to store all node # of given binary search treedef storeNodes(root): global all_nodes global leaf_nodes if (root == None): return # store all node of binary # search tree all_nodes.add(root.data) # store leaf node in leaf_hash if (root.left == None and root.right == None): leaf_nodes.add(root.data) return # recur call rest tree storeNodes(root. left) storeNodes(root.right)# Returns true if there is # a dead end in tree,# else false.def isDeadEnd(root): global all_nodes global leaf_nodes # Base case if (root == None): return False # create two empty hash # sets that store all BST # elements and leaf nodes # respectively. # insert 0 in 'all_nodes' # for handle case if bst # contain value 1 all_nodes.add(0) # Call storeNodes function # to store all BST Node storeNodes(root) # Traversal leaf node and # check Tree contain # continuous sequence of # size tree or Not for x in leaf_nodes: # Here we check first and # last element of continuous # sequence that are x-1 & x+1 if ((x + 1) in all_nodes and (x - 1) in all_nodes): return True return False# Driver codeif __name__ == '__main__': '''/* 8 / \ 5 11 / \ 2 7 \ 3 \ 4 */ ''' root = None root = insert(root, 8) root = insert(root, 5) root = insert(root, 2) root = insert(root, 3) root = insert(root, 7) root = insert(root, 11) root = insert(root, 4) if(isDeadEnd(root) == True): print("Yes") else: print("No")# This code is contributed by bgangwar59 |
Output:
Yes
Time Complexity : O(n)
Simple Recursive solution to check whether BST contains dead End
This article is contributed by Nishant_Singh(Pintu). 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.
