Check whether BST contains Dead End or not - GeeksforGeeks

07 Mar, 2022
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 set. 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 set or not.Below is a C++ implementation of the above idea.  
C++
Python3
// 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;}
# 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)    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 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 EndThis article is contributed by Nishant_Singh(Pintu). If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@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. 
bgangwar59
guptapriyanshu2001
surinderdawra388
Binary Search Tree
Hash
Tree
Hash
Binary Search Tree
Tree
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Sorted Array to Balanced BST
Inorder Successor in Binary Search Tree
Red-Black Tree | Set 2 (Insert)
Find the node with minimum value in a Binary Search Tree
Optimal Binary Search Tree | DP-24
Given an array A[] and a number x, check for pair in A[] with sum as x (aka Two Sum)
Internal Working of HashMap in Java
Hashing | Set 1 (Introduction)
Hashing | Set 3 (Open Addressing)
Count pairs with given sum