Skip to content
Related Articles

Related Articles

Check if the given n-ary tree is a binary tree

View Discussion
Improve Article
Save Article
Like Article
  • Difficulty Level : Medium
  • Last Updated : 10 Jun, 2022

Given an n-ary tree, the task is to check whether the given tree is binary or not.

Examples: 

Input: 
    A 
   / \  
  B   C
 / \   \
D   E   F
Output: Yes

Input: 
     A 
   / | \  
  B  C  D
         \
          F
Output: No

Approach: Every node in a binary tree can have at most 2 children. So, for every node of the given tree, count the number of children and if for any node the count exceeds 2 then print No else print Yes.

Below is the implementation of the above approach:  

C++




// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;
 
// Structure of a node
// of an n-ary tree
struct Node {
    char key;
    vector<Node*> child;
};
 
// Utility function to create
// a new tree node
Node* newNode(int key)
{
    Node* temp = new Node;
    temp->key = key;
    return temp;
}
 
// Function that returns true
// if the given tree is binary
bool isBinaryTree(struct Node* root)
{
 
    // Base case
    if (!root)
        return true;
 
    // Count will store the number of
    // children of the current node
    int count = 0;
    for (int i = 0; i < root->child.size(); i++) {
 
        // If any child of the current node doesn't
        // satisfy the condition of being
        // a binary tree node
        if (!isBinaryTree(root->child[i]))
            return false;
 
        // Increment the count of children
        count++;
 
        // If current node has more
        // than 2 children
        if (count > 2)
            return false;
    }
    return true;
}
 
// Driver code
int main()
{
    Node* root = newNode('A');
    (root->child).push_back(newNode('B'));
    (root->child).push_back(newNode('C'));
    (root->child[0]->child).push_back(newNode('D'));
    (root->child[0]->child).push_back(newNode('E'));
    (root->child[1]->child).push_back(newNode('F'));
 
    if (isBinaryTree(root))
        cout << "Yes";
    else
        cout << "No";
 
    return 0;
}

Java




// Java implementation of the approach
import java.util.*;
class GFG
{
 
// Structure of a node
// of an n-ary tree
static class Node
{
    int key;
    Vector<Node> child = new Vector<Node>();
};
 
// Utility function to create
// a new tree node
static Node newNode(int key)
{
    Node temp = new Node();
    temp.key = key;
    return temp;
}
 
// Function that returns true
// if the given tree is binary
static boolean isBinaryTree(Node root)
{
 
    // Base case
    if (root == null)
        return true;
 
    // Count will store the number of
    // children of the current node
    int count = 0;
    for (int i = 0; i < root.child.size(); i++)
    {
 
        // If any child of the current node doesn't
        // satisfy the condition of being
        // a binary tree node
        if (!isBinaryTree(root.child.get(i)))
            return false;
 
        // Increment the count of children
        count++;
 
        // If current node has more
        // than 2 children
        if (count > 2)
            return false;
    }
    return true;
}
 
// Driver code
public static void main(String[] args)
{
    Node root = newNode('A');
    (root.child).add(newNode('B'));
    (root.child).add(newNode('C'));
    (root.child.get(0).child).add(newNode('D'));
    (root.child.get(0).child).add(newNode('E'));
    (root.child.get(1).child).add(newNode('F'));
 
    if (isBinaryTree(root))
        System.out.println("Yes");
    else
        System.out.println("No");
}
}
 
// This code is contributed by PrinciRaj1992

Python3




# Python implementation of the approach
 
# Structure of a node of an n-ary tree
class Node:
 
    def __init__(self,key):
     
        self.key = key
        self.child = []
     
 
# Utility function to create
# a new tree node
def newNode(key):
 
    temp = Node(key)
    return temp
 
# Function that returns true
# if the given tree is binary
def isBinaryTree(root):
     
    # Base case
    if (root == None):
        return True
 
    # Count will store the number of
    # children of the current node
    count = 0
    for i in range(len(root.child)):
         
        # If any child of the current node doesn't
        # satisfy the condition of being
        # a binary tree node
        if (isBinaryTree(root.child[i]) == False):
            return False
 
        # Increment the count of children
        count += 1
 
        # If current node has more
        # than 2 children
        if (count > 2):
            return False
     
    return True
 
# Driver code
root = newNode('A')
(root.child).append(newNode('B'))
(root.child).append(newNode('C'))
(root.child[0].child).append(newNode('D'))
(root.child[0].child).append(newNode('E'))
(root.child[1].child).append(newNode('F'))
 
if (isBinaryTree(root)):
    print("Yes")
else:
    print("No")
 
# This code is contributed by shinjanpatra

C#




// C# implementation of the above approach
using System;
using System.Collections.Generic;
 
class GFG
{
 
// Structure of a node
// of an n-ary tree
public class Node
{
    public int key;
    public List<Node> child = new List<Node>();
};
 
// Utility function to create
// a new tree node
static Node newNode(int key)
{
    Node temp = new Node();
    temp.key = key;
    return temp;
}
 
// Function that returns true
// if the given tree is binary
static bool isBinaryTree(Node root)
{
 
    // Base case
    if (root == null)
        return true;
 
    // Count will store the number of
    // children of the current node
    int count = 0;
    for (int i = 0; i < root.child.Count; i++)
    {
 
        // If any child of the current node doesn't
        // satisfy the condition of being
        // a binary tree node
        if (!isBinaryTree(root.child[i]))
            return false;
 
        // Increment the count of children
        count++;
 
        // If current node has more
        // than 2 children
        if (count > 2)
            return false;
    }
    return true;
}
 
// Driver code
public static void Main(String[] args)
{
    Node root = newNode('A');
    (root.child).Add(newNode('B'));
    (root.child).Add(newNode('C'));
    (root.child[0].child).Add(newNode('D'));
    (root.child[0].child).Add(newNode('E'));
    (root.child[1].child).Add(newNode('F'));
 
    if (isBinaryTree(root))
        Console.WriteLine("Yes");
    else
        Console.WriteLine("No");
}
}
 
// This code is contributed by 29AjayKumar

Javascript




<script>
 
// Javascript implementation of the approach
 
// Structure of a node of an n-ary tree
class Node
{
    constructor(key)
    {
        this.key = key;
        this.child = [];
    }
}
 
// Utility function to create
// a new tree node
function newNode(key)
{
    let temp = new Node(key);
    return temp;
}
 
// Function that returns true
// if the given tree is binary
function isBinaryTree(root)
{
     
    // Base case
    if (root == null)
        return true;
 
    // Count will store the number of
    // children of the current node
    let count = 0;
    for(let i = 0; i < root.child.length; i++)
    {
         
        // If any child of the current node doesn't
        // satisfy the condition of being
        // a binary tree node
        if (!isBinaryTree(root.child[i]))
            return false;
 
        // Increment the count of children
        count++;
 
        // If current node has more
        // than 2 children
        if (count > 2)
            return false;
    }
    return true;
}
 
// Driver code
let root = newNode('A');
(root.child).push(newNode('B'));
(root.child).push(newNode('C'));
(root.child[0].child).push(newNode('D'));
(root.child[0].child).push(newNode('E'));
(root.child[1].child).push(newNode('F'));
 
if (isBinaryTree(root))
    document.write("Yes");
else
    document.write("No");
 
// This code is contributed by divyeshrabadiya07
 
</script>

Output: 

Yes

 


My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!