Skip to content
Related Articles

Related Articles

Improve Article

Check if each internal node of a BST has exactly one child

  • Difficulty Level : Medium
  • Last Updated : 09 Jul, 2021
Geek Week

Given Preorder traversal of a BST, check if each non-leaf node has only one child. Assume that the BST contains unique entries.

Examples  

Input: pre[] = {20, 10, 11, 13, 12}
Output: Yes
The given array represents following BST. In the following BST, every internal
node has exactly 1 child. Therefore, the output is true.
        20
       /
      10
       \
        11
          \
           13
           /
         12

In Preorder traversal, descendants (or Preorder successors) of every node appear after the node. In the above example, 20 is the first node in preorder and all descendants of 20 appear after it. All descendants of 20 are smaller than it. For 10, all descendants are greater than it. In general, we can say, if all internal nodes have only one child in a BST, then all the descendants of every node are either smaller or larger than the node. The reason is simple, since the tree is BST and every node has only one child, all descendants of a node will either be on left side or right side, means all descendants will either be smaller or greater.

Approach 1 (Naive) 
This approach simply follows the above idea that all values on right side are either smaller or larger. Use two loops, the outer loop picks an element one by one, starting from the leftmost element. The inner loop checks if all elements on the right side of the picked element are either smaller or greater. The time complexity of this method will be O(n^2).

Approach 2 
Since all the descendants of a node must either be larger or smaller than the node. We can do following for every node in a loop. 
1. Find the next preorder successor (or descendant) of the node. 
2. Find the last preorder successor (last element in pre[]) of the node. 
3. If both successors are less than the current node, or both successors are greater than the current node, then continue. Else, return false.
 



C++




#include<bits/stdc++.h>
using namespace std;
 
bool hasOnlyOneChild(int pre[], int size)
{
    int nextDiff, lastDiff;
 
    for (int i=0; i<size-1; i++)
    {
        nextDiff = pre[i] - pre[i+1];
        lastDiff = pre[i] - pre[size-1];
        if (nextDiff*lastDiff < 0)
            return false;;
    }
    return true;
}
 
// driver program to test above function
int main()
{
    int pre[] = {8, 3, 5, 7, 6};
    int size = sizeof(pre)/sizeof(pre[0]);
    if (hasOnlyOneChild(pre, size) == true )
        cout<<"Yes";
    else
        cout<<"No";
    return 0;
}
 
// This code is contributed by rrrtnx.
C



#include <stdio.h>
 
bool hasOnlyOneChild(int pre[], int size)
{
    int nextDiff, lastDiff;
 
    for (int i=0; i<size-1; i++)
    {
        nextDiff = pre[i] - pre[i+1];
        lastDiff = pre[i] - pre[size-1];
        if (nextDiff*lastDiff < 0)
            return false;;
    }
    return true;
}
 
// driver program to test above function
int main()
{
    int pre[] = {8, 3, 5, 7, 6};
    int size = sizeof(pre)/sizeof(pre[0]);
    if (hasOnlyOneChild(pre, size) == true )
        printf("Yes");
    else
        printf("No");
    return 0;
}
Java



// Check if each internal node of BST has only one child
 
class BinaryTree {
 
    boolean hasOnlyOneChild(int pre[], int size) {
        int nextDiff, lastDiff;
 
        for (int i = 0; i < size - 1; i++) {
            nextDiff = pre[i] - pre[i + 1];
            lastDiff = pre[i] - pre[size - 1];
            if (nextDiff * lastDiff < 0) {
                return false;
            };
        }
        return true;
    }
 
    public static void main(String[] args) {
        BinaryTree tree = new BinaryTree();
        int pre[] = new int[]{8, 3, 5, 7, 6};
        int size = pre.length;
        if (tree.hasOnlyOneChild(pre, size) == true) {
            System.out.println("Yes");
        } else {
            System.out.println("No");
        }
    }
}
 
// This code has been contributed by Mayank Jaiswal
Python3



# Check if each internal
# node of BST has only one child
 
def hasOnlyOneChild (pre, size):
    nextDiff=0; lastDiff=0
  
    for i in range(size-1):
        nextDiff = pre[i] - pre[i+1]
        lastDiff = pre[i] - pre[size-1]
        if nextDiff*lastDiff < 0:
            return False
    return True
  
# driver program to
# test above function
if __name__ == "__main__":
 
    pre = [8, 3, 5, 7, 6]
    size= len(pre)
 
    if (hasOnlyOneChild(pre,size) == True):
        print("Yes")
    else:
        print("No")
 
# This code is contributed by
# Harshit Saini
C#



// Check if each internal node of BST has only one child
using System;
public class BinaryTree
{
 
  bool hasOnlyOneChild(int[] pre, int size)
  {
    int nextDiff, lastDiff;
    for (int i = 0; i < size - 1; i++)
    {
      nextDiff = pre[i] - pre[i + 1];
      lastDiff = pre[i] - pre[size - 1];
      if (nextDiff * lastDiff < 0)
      {
        return false;
      };
    }
    return true;
  }
 
  // Driver code
  public static void Main(String[] args)
  {
    BinaryTree tree = new BinaryTree();
    int []pre = new int[]{8, 3, 5, 7, 6};
    int size = pre.Length;
    if (tree.hasOnlyOneChild(pre, size) == true)
    {
      Console.WriteLine("Yes");
    }
    else
    {
      Console.WriteLine("No");
    }
  }
}
 
// This code is contributed by aashish1995
Javascript



<script>
  
// Check if each internal node of BST has only one child
function hasOnlyOneChild(pre, size)
{
  var nextDiff, lastDiff;
  for (var i = 0; i < size - 1; i++)
  {
    nextDiff = pre[i] - pre[i + 1];
    lastDiff = pre[i] - pre[size - 1];
    if (nextDiff * lastDiff < 0)
    {
      return false;
    };
  }
  return true;
}
 
// Driver code
var pre = [8, 3, 5, 7, 6];
var size = pre.length;
if (hasOnlyOneChild(pre, size) == true)
{
  document.write("Yes");
}
else
{
  document.write("No");
}
 
// This code is contributed by itsok.
</script>
Output: 
 Yes 
Approach 3 
1. Scan the last two nodes of preorder & mark them as min & max. 
2. Scan every node down the preorder array. Each node must be either smaller than the min node or larger than the max node. Update min & max accordingly. 
 
C++



#include <bits/stdc++.h>
using namespace std;
 
int hasOnlyOneChild(int pre[], int size)
{
     
    // Initialize min and max using last two elements
    int min, max;
    if (pre[size - 1] > pre[size - 2])
    {
        max = pre[size - 1];
        min = pre[size - 2];
    }
    else
    {
        max = pre[size - 2];
        min = pre[size - 1];
    }
 
    // Every element must be either smaller
    // than min or greater than max
    for(int i = size - 3; i >= 0; i--)
    {
        if (pre[i] < min)
            min = pre[i];
        else if (pre[i] > max)
            max = pre[i];
        else
            return false;
    }
    return true;
}
 
// Driver code
int main()
{
    int pre[] = { 8, 3, 5, 7, 6 };
    int size = sizeof(pre) / sizeof(pre[0]);
     
    if (hasOnlyOneChild(pre,size))
        cout <<"Yes";
    else
        cout <<"No";
         
    return 0;
}
 
// This code is contributed by shivanisinghss2110
C



#include <stdio.h>
 
int hasOnlyOneChild(int pre[], int size)
{
    // Initialize min and max using last two elements
    int min, max;
    if (pre[size-1] > pre[size-2])
    {
        max = pre[size-1];
        min = pre[size-2];
    }
    else
    {
        max = pre[size-2];
        min = pre[size-1];
    }
 
 
    // Every element must be either smaller than min or
    // greater than max
    for (int i=size-3; i>=0; i--)
    {
        if (pre[i] < min)
            min = pre[i];
        else if (pre[i] > max)
            max = pre[i];
        else
            return false;
    }
    return true;
}
 
// Driver program to test above function
int main()
{
    int pre[] = {8, 3, 5, 7, 6};
    int size = sizeof(pre)/sizeof(pre[0]);
    if (hasOnlyOneChild(pre,size))
        printf("Yes");
    else
        printf("No");
    return 0;
}
Java



// Check if each internal node of BST has only one child
 
class BinaryTree {
 
    boolean hasOnlyOneChild(int pre[], int size) {
        // Initialize min and max using last two elements
        int min, max;
        if (pre[size - 1] > pre[size - 2]) {
            max = pre[size - 1];
            min = pre[size - 2];
        } else {
            max = pre[size - 2];
            min = pre[size - 1];
        }
 
        // Every element must be either smaller than min or
        // greater than max
        for (int i = size - 3; i >= 0; i--) {
            if (pre[i] < min) {
                min = pre[i];
            } else if (pre[i] > max) {
                max = pre[i];
            } else {
                return false;
            }
        }
        return true;
    }
 
    public static void main(String[] args) {
        BinaryTree tree = new BinaryTree();
        int pre[] = new int[]{8, 3, 5, 7, 6};
        int size = pre.length;
        if (tree.hasOnlyOneChild(pre, size) == true) {
            System.out.println("Yes");
        } else {
            System.out.println("No");
        }
    }
}
 
// This code has been contributed by Mayank Jaiswal
Python3



# Check if each internal
# node of BST has only one child
# approach 2
 
def hasOnlyOneChild(pre,size):
 
    # Initialize min and max
    # using last two elements
    min=0; max=0
 
    if pre[size-1] > pre[size-2] :
        max = pre[size-1]
        min = pre[size-2]
    else :
        max = pre[size-2]
        min = pre[size-1]
  
    # Every element must be
    # either smaller than min or
    # greater than max
    for i in range(size-3, 0, -1):
        if pre[i] < min:
            min = pre[i]
        elif pre[i] > max:
            max = pre[i]
        else:
            return False
    return True
  
# Driver program to
# test above function
if __name__ == "__main__":
 
    pre = [8, 3, 5, 7, 6]
 
    size = len(pre)
    if (hasOnlyOneChild(pre, size)):
        print("Yes")
    else:
        print("No")
 
# This code is contributed by
# Harshit Saini
C#



// Check if each internal node of BST has only one child
using System;
public class BinaryTree
{
 
  bool hasOnlyOneChild(int []pre, int size)
  {
 
    // Initialize min and max using last two elements
    int min, max;
    if (pre[size - 1] > pre[size - 2]) {
      max = pre[size - 1];
      min = pre[size - 2];
    } else {
      max = pre[size - 2];
      min = pre[size - 1];
    }
 
    // Every element must be either smaller than min or
    // greater than max
    for (int i = size - 3; i >= 0; i--) {
      if (pre[i] < min) {
        min = pre[i];
      } else if (pre[i] > max) {
        max = pre[i];
      } else {
        return false;
      }
    }
    return true;
  }
 
  // Driver code
  public static void Main(String[] args)
  {
    BinaryTree tree = new BinaryTree();
    int []pre = new int[]{8, 3, 5, 7, 6};
    int size = pre.Length;
    if (tree.hasOnlyOneChild(pre, size) == true)
    {
      Console.WriteLine("Yes");
    }
    else
    {
      Console.WriteLine("No");
    }
  }
}
 
// This code is contributed by aashish1995
Javascript



<script>
 
      // Check if each internal node of BST
      // has only one child
      class BinaryTree {
        hasOnlyOneChild(pre, size) {
          // Initialize min and max using
          // last two elements
          var min, max;
          if (pre[size - 1] > pre[size - 2]) {
            max = pre[size - 1];
            min = pre[size - 2];
          } else {
            max = pre[size - 2];
            min = pre[size - 1];
          }
 
          // Every element must be either
          // smaller than min or
          // greater than max
          for (var i = size - 3; i >= 0; i--) {
            if (pre[i] < min) {
              min = pre[i];
            } else if (pre[i] > max) {
              max = pre[i];
            } else {
              return false;
            }
          }
          return true;
        }
      }
      // Driver code
      var tree = new BinaryTree();
      var pre = [8, 3, 5, 7, 6];
      var size = pre.length;
      if (tree.hasOnlyOneChild(pre, size) == true) {
        document.write("Yes");
      } else {
        document.write("No");
      }
       
</script>
Output: 
Yes
 
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.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.
In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.



My Personal Notes
arrow_drop_up
Previous
Find a triplet from three linked lists with sum equal to a given number
Next

Generate integer from 1 to 7 with equal probability
Recommended Articles
Page :
Convert a normal BST to Balanced BST
01, May 16
K'th Largest Element in BST when modification to BST is not allowed
19, Mar 15
Find k-th smallest element in BST (Order Statistics in BST)
15, Feb 11
Two nodes of a BST are swapped, correct the BST | Set-2
12, Jun 19
Two nodes of a BST are swapped, correct the BST
14, Sep 12
Convert a Binary Tree to BST by left shifting digits of node values
20, Jan 21
Add all greater values to every node in a given BST
12, Sep 13
Implementing a BST where every node stores the maximum number of nodes in the path till any leaf
14, Aug 19
Sum of all nodes with smaller values at a distance K from a given node in a BST
10, Aug 21
Sum of cousin nodes of a given node in a BST
09, Aug 18
Total sum except adjacent of a given node in BST
31, Aug 18
Simple Recursive solution to check whether BST contains dead end
20, Jan 18
Check if a Binary Tree is BST : Simple and Efficient Approach
28, Nov 19
Check given array of size n can represent BST of n levels or not
07, Mar 18
Check if a triplet with given sum exists in BST
07, Dec 18
Check if the Binary Tree contains a balanced BST of size K
06, Jul 20
Check whether BST contains Dead End or not
02, Jan 17
A program to check if a binary tree is BST or not
21, Nov 09
Sorted order printing of a given array that represents a BST
13, Dec 10
K'th smallest element in BST using O(1) Extra Space
16, Jul 15
Find if there is a triplet in a Balanced BST that adds to zero
09, Mar 13
Remove BST keys outside the given range
29, Mar 13
Transform a BST to greater sum tree
27, Jun 14
Advantages of BST over Hash Table
01, Apr 15
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
GeeksforGeeks
Vote for difficulty
Current difficulty :
Medium





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox