# Construct a Perfect Binary Tree with given Height

• Last Updated : 26 Dec, 2022

Given an integer N, the task is to generate a perfect binary tree with height N such that each node has a value that is the same as its depth. Return the inorder traversal of the generated binary tree.

A Perfect binary tree is a type of binary tree where every internal node has exactly two child nodes and all leaf nodes are at same level.

Examples:

Input: N = 2
Output: 2 1 2 0 2 1 2
Explanation: The structure of the tree is as following

Perfect Binary Tree with height 2

Input: N = 1
Output: 1 0 1

Approach: The problem can be solved using level order traversal based on the following observation:

As there is a requirement to fill each node with the value that is the same as its depth so use the level order traversal. In each step fill a total level and mark all the nodes with the value same as the depth.

Follow the steps mentioned below to implement the approach:

• Initiate a variable to store the depth of the current level.
• Initiate a queue to store the node of each level and perform the level order traversal.
• In each iteration get all the nodes in that level and continue the following until the depth is N:
• Increase the depth by 1.
• Pop the nodes at the current level.
• Generate the child nodes for each node.
• Add the new child nodes for further processing.
• After the traversal is complete, the tree is prepared.
• Print the inorder traversal of the tree.

Below is the implementation of the above approach.

## Java

 `// Java code to implement the approach`   `import` `java.util.*;`   `// Class to hold tree node data` `// and left, right children` `class` `TreeNode {` `    ``public` `long` `val;` `    ``public` `TreeNode left;` `    ``public` `TreeNode right;`   `    ``public` `TreeNode(``long` `x)` `    ``{` `        ``val = x;` `        ``left = ``null``;` `        ``right = ``null``;` `    ``}` `}`   `// Class to create the perfect binary tree` `class` `BinaryTree {`   `    ``// Method to construct a binary tree` `    ``public` `static` `TreeNode perfectBinaryTree(``int` `depth)` `    ``{` `        ``// Return root with 0 as val if height is 0` `        ``if` `(depth == ``0``)` `            ``return` `new` `TreeNode(``0``);`   `        ``// Initiate queue to store` `        ``// the nodes on each level` `        ``Queue queue` `            ``= ``new` `LinkedList<>();`   `        ``// Create a root node with value 0` `        ``long` `i = ``0``;` `        ``TreeNode root = ``new` `TreeNode(i);`   `        ``// Add the root node to the queue` `        ``// for further processing` `        ``queue.add(root);`   `        ``// Iterate through the queue till its empty` `        ``while` `(!queue.isEmpty()) {`   `            ``// Check the size of the queue to iterate` `            ``// through each node on the same level` `            ``int` `size = queue.size();`   `            ``// Increment the value of node` `            ``// upon each level` `            ``i++;`   `            ``// Break the loop if the value of the node` `            ``// reaches given depth` `            ``// else process the node in the queue` `            ``if` `(i > depth) {` `                ``break``;` `            ``}` `            ``else` `{` `                ``// Add the left and right child` `                ``// for the node in the queue and` `                ``// add those newly created child nodes` `                ``// to the queue.` `                ``for` `(``int` `j = ``0``; j < size; j++) {` `                    ``TreeNode node = queue.remove();` `                    ``node.left = ``new` `TreeNode(i);` `                    ``node.right = ``new` `TreeNode(i);`   `                    ``queue.add(node.left);` `                    ``queue.add(node.right);` `                ``}` `            ``}` `        ``}`   `        ``// Return the root of the tree` `        ``return` `root;` `    ``}`   `    ``// Inorder traversal of the tree (Left Root Right)` `    ``public` `static` `void` `inOrderTraversal(TreeNode node)` `    ``{` `        ``if` `(node == ``null``)` `            ``return``;` `        ``inOrderTraversal(node.left);` `        ``System.out.print(node.val + ``" "``);` `        ``inOrderTraversal(node.right);` `    ``}`   `    ``// Driver code` `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``int` `N = ``2``;`   `        ``// Function call to build the tree` `        ``TreeNode binaryTreeRoot` `            ``= perfectBinaryTree(N);`   `        ``// Function call to print the tree` `        ``inOrderTraversal(binaryTreeRoot);` `    ``}` `}`

## C#

 `// C# code to implement the approach` `using` `System;` `using` `System.Collections.Generic;`   `// Class to hold tree node data` `// and left, right children` `public` `class` `TreeNode {` `  ``public` `long` `val;` `  ``public` `TreeNode left;` `  ``public` `TreeNode right;`   `  ``public` `TreeNode(``long` `x) {` `    ``val = x;` `    ``left = ``null``;` `    ``right = ``null``;` `  ``}` `}`   `// Class to create the perfect binary tree` `public` `class` `BinaryTree {`   `  ``// Method to construct a binary tree` `  ``public` `static` `TreeNode perfectBinaryTree(``int` `depth) {` `    ``// Return root with 0 as val if height is 0` `    ``if` `(depth == 0)` `      ``return` `new` `TreeNode(0);`   `    ``// Initiate queue to store` `    ``// the nodes on each level` `    ``Queue queue = ``new` `Queue();`   `    ``// Create a root node with value 0` `    ``long` `i = 0;` `    ``TreeNode root = ``new` `TreeNode(i);`   `    ``// Add the root node to the queue` `    ``// for further processing` `    ``queue.Enqueue(root);`   `    ``// Iterate through the queue till its empty` `    ``while` `(queue.Count!=0) {`   `      ``// Check the size of the queue to iterate` `      ``// through each node on the same level` `      ``int` `size = queue.Count;`   `      ``// Increment the value of node` `      ``// upon each level` `      ``i++;`   `      ``// Break the loop if the value of the node` `      ``// reaches given depth` `      ``// else process the node in the queue` `      ``if` `(i > depth) {` `        ``break``;` `      ``} ``else` `{` `        ``// Add the left and right child` `        ``// for the node in the queue and` `        ``// add those newly created child nodes` `        ``// to the queue.` `        ``for` `(``int` `j = 0; j < size; j++) {` `          ``TreeNode node = queue.Dequeue();` `          ``node.left = ``new` `TreeNode(i);` `          ``node.right = ``new` `TreeNode(i);`   `          ``queue.Enqueue(node.left);` `          ``queue.Enqueue(node.right);` `        ``}` `      ``}` `    ``}`   `    ``// Return the root of the tree` `    ``return` `root;` `  ``}`   `  ``// Inorder traversal of the tree (Left Root Right)` `  ``public` `static` `void` `inOrderTraversal(TreeNode node) {` `    ``if` `(node == ``null``)` `      ``return``;` `    ``inOrderTraversal(node.left);` `    ``Console.Write(node.val + ``" "``);` `    ``inOrderTraversal(node.right);` `  ``}`   `  ``// Driver code` `  ``public` `static` `void` `Main(String[] args) {` `    ``int` `N = 2;`   `    ``// Function call to build the tree` `    ``TreeNode binaryTreeRoot = perfectBinaryTree(N);`   `    ``// Function call to print the tree` `    ``inOrderTraversal(binaryTreeRoot);` `  ``}` `}`   `// This code is contributed by shikhasingrajput`

## Javascript

 `        ``// JavaScript code for the above approach` `        ``class TreeNode {` `    ``constructor(val) {` `        ``this``.val = val;` `        ``this``.left = ``null``;` `        ``this``.right = ``null``;` `    ``}` `}`   `class BinaryTree {` `    ``static perfectBinaryTree(depth) {` `        ``if` `(depth === 0) {` `            ``return` `new` `TreeNode(0);` `        ``}`   `        ``const queue = [];` `        ``let i = 0;` `        ``const root = ``new` `TreeNode(i);` `        ``queue.push(root);`   `        ``while` `(queue.length > 0) {` `            ``const size = queue.length;` `            ``i++;` `            ``if` `(i > depth) {` `                ``break``;` `            ``}` `            ``else` `{` `                ``for` `(let j = 0; j < size; j++) {` `                    ``const node = queue.shift();` `                    ``node.left = ``new` `TreeNode(i);` `                    ``node.right = ``new` `TreeNode(i);` `                    ``queue.push(node.left);` `                    ``queue.push(node.right);` `                ``}` `            ``}` `        ``}`   `        ``return` `root;` `    ``}`   `    ``static inOrderTraversal(node) {` `        ``if` `(node === ``null``) ``return``;` `        ``this``.inOrderTraversal(node.left);` `        ``console.log(node.val + ``" "``);` `        ``this``.inOrderTraversal(node.right);` `    ``}` `}`   `const N = 2;` `const binaryTreeRoot = BinaryTree.perfectBinaryTree(N);` `BinaryTree.inOrderTraversal(binaryTreeRoot);`   ` ``// This code is contributed by Potta Lokesh.`

Output

`2 1 2 0 2 1 2 `

Time Complexity: O(2N)
Auxiliary Space: O(2N)

My Personal Notes arrow_drop_up
Related Articles