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

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
        // satify 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
        // satify 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

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
        // satify 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

Output:

Yes

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.