# Check whether a binary tree is a full binary tree or not

A full binary tree is defined as a binary tree in which all nodes have either zero or two child nodes. Conversely, there is no node in a full binary tree, which has one child node. More information about full binary trees can be found here.

For Example :

Recommended Practice

To check whether a binary tree is a full binary tree we need to test the following cases:-

1. If a binary tree node is NULL then it is a full binary tree.
2. If a binary tree node does have empty left and right sub-trees, then it is a full binary tree by definition.
3. If a binary tree node has left and right sub-trees, then it is a part of a full binary tree by definition. In this case recursively check if the left and right sub-trees are also binary trees themselves.
4. In all other combinations of right and left sub-trees, the binary tree is not a full binary tree.

Following is the implementation for checking if a binary tree is a full binary tree.

## C++

 `// C++ program to check whether a given Binary Tree is full or not``#include ` `using` `namespace` `std;`` ` `/*  Tree node structure */``struct` `Node``{``    ``int` `key;``    ``struct` `Node *left, *right;``};`` ` `/* Helper function that allocates a new node with the``   ``given key and NULL left and right pointer. */``struct` `Node *newNode(``char` `k)``{``    ``struct` `Node *node = ``new`  `Node;``    ``node->key = k;``    ``node->right = node->left = NULL;``    ``return` `node;``}`` ` `/* This function tests if a binary tree is a full binary tree. */``bool` `isFullTree (``struct` `Node* root)``{``    ``// If empty tree``    ``if` `(root == NULL)``        ``return` `true``;`` ` `    ``// If leaf node``    ``if` `(root->left == NULL && root->right == NULL)``        ``return` `true``;`` ` `    ``// If both left and right are not NULL, and left & right subtrees``    ``// are full``    ``if` `((root->left) && (root->right))``        ``return` `(isFullTree(root->left) && isFullTree(root->right));`` ` `    ``// We reach here when none of the above if conditions work``    ``return` `false``;``}`` ` `// Driver Program``int` `main()``{``    ``struct` `Node* root = NULL;``    ``root = newNode(10);``    ``root->left = newNode(20);``    ``root->right = newNode(30);`` ` `    ``root->left->right = newNode(40);``    ``root->left->left = newNode(50);``    ``root->right->left = newNode(60);``    ``root->right->right = newNode(70);`` ` `    ``root->left->left->left = newNode(80);``    ``root->left->left->right = newNode(90);``    ``root->left->right->left = newNode(80);``    ``root->left->right->right = newNode(90);``    ``root->right->left->left = newNode(80);``    ``root->right->left->right = newNode(90);``    ``root->right->right->left = newNode(80);``    ``root->right->right->right = newNode(90);`` ` `    ``if` `(isFullTree(root))``        ``cout << ``"The Binary Tree is full\n"``;``    ``else``        ``cout << ``"The Binary Tree is not full\n"``;`` ` `    ``return``(0);``}` `// This code is contributed by shubhamsingh10`

## C

 `// C program to check whether a given Binary Tree is full or not``#include``#include``#include` `/*  Tree node structure */``struct` `Node``{``    ``int` `key;``    ``struct` `Node *left, *right;``};` `/* Helper function that allocates a new node with the``   ``given key and NULL left and right pointer. */``struct` `Node *newNode(``char` `k)``{``    ``struct` `Node *node = (``struct` `Node*)``malloc``(``sizeof``(``struct` `Node));``    ``node->key = k;``    ``node->right = node->left = NULL;``    ``return` `node;``}` `/* This function tests if a binary tree is a full binary tree. */``bool` `isFullTree (``struct` `Node* root)``{``    ``// If empty tree``    ``if` `(root == NULL)``        ``return` `true``;` `    ``// If leaf node``    ``if` `(root->left == NULL && root->right == NULL)``        ``return` `true``;` `    ``// If both left and right are not NULL, and left & right subtrees``    ``// are full``    ``if` `((root->left) && (root->right))``        ``return` `(isFullTree(root->left) && isFullTree(root->right));` `    ``// We reach here when none of the above if conditions work``    ``return` `false``;``}` `// Driver Program``int` `main()``{``    ``struct` `Node* root = NULL;``    ``root = newNode(10);``    ``root->left = newNode(20);``    ``root->right = newNode(30);` `    ``root->left->right = newNode(40);``    ``root->left->left = newNode(50);``    ``root->right->left = newNode(60);``    ``root->right->right = newNode(70);` `    ``root->left->left->left = newNode(80);``    ``root->left->left->right = newNode(90);``    ``root->left->right->left = newNode(80);``    ``root->left->right->right = newNode(90);``    ``root->right->left->left = newNode(80);``    ``root->right->left->right = newNode(90);``    ``root->right->right->left = newNode(80);``    ``root->right->right->right = newNode(90);` `    ``if` `(isFullTree(root))``        ``printf``(``"The Binary Tree is full\n"``);``    ``else``        ``printf``(``"The Binary Tree is not full\n"``);` `    ``return``(0);``}`

## Java

 `// Java program to check if binary tree is full or not` `/*  Tree node structure */``class` `Node ``{``    ``int` `data;``    ``Node left, right;`` ` `    ``Node(``int` `item) ``    ``{``        ``data = item;``        ``left = right = ``null``;``    ``}``}`` ` `class` `BinaryTree ``{``    ``Node root;``     ` `    ``/* this function checks if a binary tree is full or not */``    ``boolean` `isFullTree(Node node)``    ``{``        ``// if empty tree``        ``if``(node == ``null``)``        ``return` `true``;``         ` `        ``// if leaf node``        ``if``(node.left == ``null` `&& node.right == ``null` `)``            ``return` `true``;``         ` `        ``// if both left and right subtrees are not null``        ``// they are full``        ``if``((node.left!=``null``) && (node.right!=``null``))``            ``return` `(isFullTree(node.left) && isFullTree(node.right));``         ` `        ``// if none work``        ``return` `false``;``    ``}`` ` `     ` `    ``// Driver program``    ``public` `static` `void` `main(String args[]) ``    ``{``        ``BinaryTree tree = ``new` `BinaryTree();``        ``tree.root = ``new` `Node(``10``);``        ``tree.root.left = ``new` `Node(``20``);``        ``tree.root.right = ``new` `Node(``30``);``        ``tree.root.left.right = ``new` `Node(``40``);``        ``tree.root.left.left = ``new` `Node(``50``);``        ``tree.root.right.left = ``new` `Node(``60``);``        ``tree.root.left.left.left = ``new` `Node(``80``);``        ``tree.root.right.right = ``new` `Node(``70``);``        ``tree.root.left.left.right = ``new` `Node(``90``);``        ``tree.root.left.right.left = ``new` `Node(``80``);``        ``tree.root.left.right.right = ``new` `Node(``90``);``        ``tree.root.right.left.left = ``new` `Node(``80``);``        ``tree.root.right.left.right = ``new` `Node(``90``);``        ``tree.root.right.right.left = ``new` `Node(``80``);``        ``tree.root.right.right.right = ``new` `Node(``90``);``         ` `        ``if``(tree.isFullTree(tree.root))``            ``System.out.print(``"The binary tree is full"``);``        ``else``            ``System.out.print(``"The binary tree is not full"``); ``    ``}``}`` ` `// This code is contributed by Mayank Jaiswal `

## Python3

 `# Python program to check whether given Binary tree is full or not` `# Tree node structure``class` `Node:` `    ``# Constructor of the node class for creating the node``    ``def` `__init__(``self` `, key):``        ``self``.key ``=` `key``        ``self``.left ``=` `None``        ``self``.right ``=` `None` `# Checks if the binary tree is full or not``def` `isFullTree(root):` `    ``# If empty tree``    ``if` `root ``is` `None``:    ``        ``return` `True``    ` `    ``# If leaf node``    ``if` `root.left ``is` `None` `and` `root.right ``is` `None``:``        ``return` `True` `    ``# If both left and right subtress are not None and``    ``# left and right subtress are full``    ``if` `root.left ``is` `not` `None` `and` `root.right ``is` `not` `None``:``        ``return` `(isFullTree(root.left) ``and` `isFullTree(root.right))``    ` `    ``# We reach here when none of the above if conditions work``    ``return` `False` `# Driver Program``root ``=` `Node(``10``);``root.left ``=` `Node(``20``);``root.right ``=` `Node(``30``);` `root.left.right ``=` `Node(``40``);``root.left.left ``=` `Node(``50``);``root.right.left ``=` `Node(``60``);``root.right.right ``=` `Node(``70``);` `root.left.left.left ``=` `Node(``80``);``root.left.left.right ``=` `Node(``90``);``root.left.right.left ``=` `Node(``80``);``root.left.right.right ``=` `Node(``90``);``root.right.left.left ``=` `Node(``80``);``root.right.left.right ``=` `Node(``90``);``root.right.right.left ``=` `Node(``80``);``root.right.right.right ``=` `Node(``90``);` `if` `isFullTree(root):``    ``print` `(``"The Binary tree is full"``)``else``:``    ``print` `(``"Binary tree is not full"``)` `# This code is contributed by Nikhil Kumar Singh(nickzuck_007)`

## C#

 `// C# program to check if binary tree ``// is full or not ``using` `System;` `/* Tree node structure */``public` `class` `Node``{``    ``public` `int` `data;``    ``public` `Node left, right;` `    ``public` `Node(``int` `item)``    ``{``        ``data = item;``        ``left = right = ``null``;``    ``}``}` `class` `GFG``{``public` `Node root;` `/* This function checks if a binary``tree is full or not */``public` `virtual` `bool` `isFullTree(Node node)``{``    ``// if empty tree ``    ``if` `(node == ``null``)``    ``{``    ``return` `true``;``    ``}` `    ``// if leaf node ``    ``if` `(node.left == ``null` `&& node.right == ``null``)``    ``{``        ``return` `true``;``    ``}` `    ``// if both left and right subtrees ``    ``// are not null they are full ``    ``if` `((node.left != ``null``) && (node.right != ``null``))``    ``{``        ``return` `(isFullTree(node.left) && ``                ``isFullTree(node.right));``    ``}` `    ``// if none work ``    ``return` `false``;``}` `// Driver Code ``public` `static` `void` `Main(``string``[] args)``{``    ``GFG tree = ``new` `GFG();``    ``tree.root = ``new` `Node(10);``    ``tree.root.left = ``new` `Node(20);``    ``tree.root.right = ``new` `Node(30);``    ``tree.root.left.right = ``new` `Node(40);``    ``tree.root.left.left = ``new` `Node(50);``    ``tree.root.right.left = ``new` `Node(60);``    ``tree.root.left.left.left = ``new` `Node(80);``    ``tree.root.right.right = ``new` `Node(70);``    ``tree.root.left.left.right = ``new` `Node(90);``    ``tree.root.left.right.left = ``new` `Node(80);``    ``tree.root.left.right.right = ``new` `Node(90);``    ``tree.root.right.left.left = ``new` `Node(80);``    ``tree.root.right.left.right = ``new` `Node(90);``    ``tree.root.right.right.left = ``new` `Node(80);``    ``tree.root.right.right.right = ``new` `Node(90);` `    ``if` `(tree.isFullTree(tree.root))``    ``{``        ``Console.Write(``"The binary tree is full"``);``    ``}``    ``else``    ``{``        ``Console.Write(``"The binary tree is not full"``);``    ``}``}``}` `// This code is contributed by Shrikant13`

## Javascript

 ``

Output
`The Binary Tree is full`

Time complexity: O(n) where n is number of nodes in given binary tree.
Auxiliary Space: O(n) for call stack since using recursion

Iterative Approach:

To check whether a binary tree is a full binary tree we need to test the following cases:-

1. Create a queue to store nodes
2. Store the root of the tree in the queue
3. Traverse until the queue is not empty
1. If the current node is not a leaf insert root->left and root->right in the queue.
2. If the current node is NULL return false.
4. If the queue is empty return true.

Following is the implementation for checking if a binary tree is a full binary tree.

## C++

 `// c++ program to check whether a given BT is full or not``#include ``using` `namespace` `std;` `// Tree node structure``struct` `Node {``    ``int` `val;``    ``Node *left, *right;``};` `// fun that creates and returns a new node``Node* newNode(``int` `data)``{``    ``Node* node = ``new` `Node();``    ``node->val = data;``    ``node->left = node->right = NULL;``    ``return` `node;``}` `// helper fun to check leafnode``bool` `isleafnode(Node* root)``{``    ``return` `!root->left && !root->right;``}` `// fun checks whether the given BT is a full BT or not``bool` `isFullTree(Node* root)``{``    ``// if tree is empty``    ``if` `(!root)``        ``return` `true``;` `    ``queue q;``    ``q.push(root);` `    ``while` `(!q.empty()) {` `        ``root = q.front();``        ``q.pop();` `        ``// null indicates - not a full BT``        ``if` `(root == NULL)``            ``return` `false``;` `        ``// if its not a leafnode then the current node``        ``// should contain both left and right pointers.``        ``if` `(!isleafnode(root)) {``            ``q.push(root->left);``            ``q.push(root->right);``        ``}``    ``}` `    ``return` `true``;``}` `int` `main()``{``    ``Node* root = newNode(1);``    ``root->left = newNode(2);``    ``root->right = newNode(3);``    ``root->left->left = newNode(4);``    ``root->left->right = newNode(5);` `    ``if` `(isFullTree(root))``        ``cout << ``"The Binary Tree is full\n"``;``    ``else``        ``cout << ``"The Binary Tree is not full\n"``;` `    ``return` `0;``}``// This code is contributed by Modem Upendra.`

## Java

 `// Java program to check whether a given BT is full or not``import` `java.util.ArrayDeque;``import` `java.util.Queue;` `public` `class` `GFG ``{` `  ``/*  Tree node structure */``  ``static` `class` `Node {``    ``int` `data;``    ``Node left, right;` `    ``Node(``int` `item)``    ``{``      ``data = item;``      ``left = right = ``null``;``    ``}``  ``}` `  ``// helper fun to check leafnode``  ``static` `boolean` `isleafnode(Node root)``  ``{``    ``return` `root.left == ``null` `&& root.right == ``null``;``  ``}` `  ``// fun checks whether the given BT is a full BT or not``  ``static` `boolean` `isFullTree(Node root)``  ``{` `    ``// if tree is empty``    ``if` `(root == ``null``)``      ``return` `true``;` `    ``Queue q = ``new` `ArrayDeque<>();``    ``q.add(root);` `    ``while` `(!q.isEmpty()) {` `      ``root = q.peek();``      ``q.remove();` `      ``// null indicates - not a full BT``      ``if` `(root == ``null``)``        ``return` `false``;` `      ``// if its not a leafnode then the current node``      ``// should contain both left and right pointers.``      ``if` `(!isleafnode(root)) {``        ``q.add(root.left);``        ``q.add(root.right);``      ``}``    ``}` `    ``return` `true``;``  ``}` `  ``// Driver Code``  ``public` `static` `void` `main(String[] args)``  ``{``    ``Node root = ``new` `Node(``1``);``    ``root.left = ``new` `Node(``2``);``    ``root.right = ``new` `Node(``3``);``    ``root.left.left = ``new` `Node(``4``);``    ``root.left.right = ``new` `Node(``5``);` `    ``if` `(isFullTree(root))``      ``System.out.println(``"The Binary Tree is full"``);``    ``else``      ``System.out.println(``      ``"The Binary Tree is not full"``);``  ``}``}` `// This code is contributed by karandeep1234`

## Python3

 `# Python program to check whether a given BT is full or not``# Tree Structure``class` `Node:``    ``def` `__init__(``self``, key):``        ``self``.data ``=` `key``        ``self``.left ``=` `None``        ``self``.right ``=` `None` `# function that creates and returns a new node``def` `newNode(data):``    ``node ``=` `Node(data)``    ``return` `node` `# helper function to check leafnode``def` `isleafnode(root):``    ``return` `root.left ``is` `not` `None` `and` `root.right ``is` `not` `None` `# function checks whether the given BT is a full BT or not``def` `isFullTree(root):``    ``# if tree is empty``    ``if` `root ``is` `None``:``        ``return` `True` `    ``q ``=` `[]``    ``q.append(root)` `    ``while``(``len``(q) > ``0``):``        ``root ``=` `q.pop(``0``)` `        ``# null indicates - not a full BT``        ``if` `root ``is` `None``:``            ``return` `False` `        ``# if its not a leafnode then the current node``        ``# should contain both left and right pointers``        ``if` `isleafnode(root) ``is` `False``:``            ``q.append(root.left)``            ``q.append(root.right)` `    ``return` `True` `# Driver program to test above function``root ``=` `newNode(``1``)``root.left ``=` `newNode(``2``)``root.right ``=` `newNode(``3``)``root.left.left ``=` `newNode(``4``)``root.left.right ``=` `newNode(``5``)` `if` `isFullTree(root) ``is` `True``:``    ``print``(``"The Binary Tree is full"``)``else``:``    ``print``(``"The Binary Tree is not full"``)` `# This code is contributed by Yash Agarwal(yashagarwal2852002)`

## C#

 `// C# program to check whether a given BT is full or not` `using` `System;``using` `System.Collections.Generic;` `public` `class` `GFG {` `    ``/*  Tree node structure */``    ``public` `class` `Node {``        ``public` `int` `data;``        ``public` `Node left, right;` `        ``public` `Node(``int` `item)``        ``{``            ``data = item;``            ``left = right = ``null``;``        ``}``    ``}` `    ``// helper fun to check leafnode``    ``static` `bool` `isleafnode(Node root)``    ``{``        ``return` `root.left == ``null` `&& root.right == ``null``;``    ``}` `    ``// fun checks whether the given BT is a full BT or not``    ``static` `bool` `isFullTree(Node root)``    ``{` `        ``// if tree is empty``        ``if` `(root == ``null``)``            ``return` `true``;` `        ``Queue q = ``new` `Queue();``        ``q.Enqueue(root);` `        ``while` `(q.Count != 0) {` `            ``root = q.Dequeue();` `            ``// null indicates - not a full BT``            ``if` `(root == ``null``)``                ``return` `false``;` `            ``// if its not a leafnode then the current node``            ``// should contain both left and right pointers.``            ``if` `(!isleafnode(root)) {``                ``q.Enqueue(root.left);``                ``q.Enqueue(root.right);``            ``}``        ``}` `        ``return` `true``;``    ``}` `    ``// Driver Code``    ``public` `static` `void` `Main(``string``[] args)``    ``{``        ``Node root = ``new` `Node(1);``        ``root.left = ``new` `Node(2);``        ``root.right = ``new` `Node(3);``        ``root.left.left = ``new` `Node(4);``        ``root.left.right = ``new` `Node(5);` `        ``if` `(isFullTree(root))``            ``Console.WriteLine(``"The Binary Tree is full"``);``        ``else``            ``Console.WriteLine(``                ``"The Binary Tree is not full"``);``    ``}``}``// This code is contributed by karandeep1234.`

## Javascript

 `// JAVASCRIPT program to check whether a given BT is full or not``class Queue {``    ``constructor() {``        ``this``.items = [];``    ``}``    ` `    ``// add element to the queue``    ``enqueue(element) {``        ``return` `this``.items.push(element);``    ``}``    ` `    ``// remove element from the queue``    ``dequeue() {``        ``if``(``this``.items.length > 0) {``            ``return` `this``.items.shift();``        ``}``    ``}``    ` `    ``// view the last element``    ``peek() {``        ``return` `this``.items[0];``    ``}``    ` `    ``// check if the queue is empty``    ``isEmpty(){``       ``return` `this``.items.length == 0;``    ``}``   ` `    ``// the size of the queue``    ``size(){``        ``return` `this``.items.length;``    ``}`` ` `    ``// empty the queue``    ``clear(){``        ``this``.items = [];``    ``}``}``// Tree node structure``class Node {``    ``constructor(item) {``        ``this``.data = item;``        ``this``.left = ``this``.right = ``null``;``    ``}``}` `// helper fun to check leafnode``function` `isleafnode(root)``{``    ``if``(root.left==``null` `&& root.right==``null``)``        ``return` `true``;``    ``return` `false``;``    ` `}` `// fun checks whether the given BT is a full BT or not``function` `isFullTree( root)``{``    ``// if tree is empty``    ``if` `(root==``null``)``        ``return` `true``;``  ``let q = ``new` `Queue();``    ``q.enqueue(root)``    ``while` `(q.size()!=0) {` `        ``root = q.peek();``        ``q.dequeue();``        ``// null indicates - not a full BT``        ``if` `(root == ``null``)``            ``return` `false``;``        ` `        ``// if its not a leafnode then the current node``        ``// should contain both left and right pointers.``        ``if` `(isleafnode(root)==``false``) {``            ``q.enqueue(root.left);``            ``q.enqueue(root.right);``        ``}``    ``}` `    ``return` `true``;``}` `    ``let root = ``new` `Node(1);``    ``root.left = ``new` `Node(2);``    ``root.right = ``new` `Node(3);``    ``root.left.left = ``new` `Node(4);``    ``root.left.right = ``new` `Node(5);` `    ``if` `(isFullTree(root)== ``true``)``        ``console.log(``"The Binary Tree is full"``);``    ``else``        ``console.log(``"The Binary Tree is not full"``);` `   ``// This code is contributed by garg28harsh.`

Output
`The Binary Tree is full`

Time Complexity: O(N), Where N is the total nodes in a given binary tree.
Auxiliary Space: O(N), in most cases the last level contains nodes as half of the total nodes. O(N/2) ~ O(N)

Previous
Next