# Modify Binary Tree by replacing all nodes at even and odd levels by their nearest even or odd perfect squares respectively

• Last Updated : 01 Jul, 2021

Given a Binary Tree consisting of N nodes, the task is to replace all the nodes that are present at even-numbered levels in a Binary Tree with their nearest even perfect square and replace nodes at odd-numbered levels with their nearest odd perfect square.

Examples:

Input:           5
/    \
3       2
/    \
16    19

Output:        9
/    \
4       4
/    \
9     25

Explanation:
Level 1: Nearest odd perfect square to 5 is 9.
Level 2: Nearest even perfect square to 3 and 2 are 4.
Level 3: Nearest odd perfect square to 16 is 9 and to 19 is 25.

Input:          45
/    \
65     32
/
89

Output:       49
/    \
64    36
/
81

Explanation:
Level 1: Nearest odd perfect square to 45 is 49.
Level 2: Nearest even perfect square to 65 and 32 are 64 and 36 respectively.
Level 3: Nearest odd perfect square to 89 is 81.

Approach: The given problem can be solved using Level Order Traversal. Follow the steps below to solve the problem:

1. Initialize a queue, say q.
2. Push root into the queue.
3. Loop while the queue is not empty
• Store the current node in a variable, say temp_node.
• If the current node value is a perfect square, check the following:
• If the value of level is odd, and the value of the current node is even, find the nearest odd perfect square and update temp_nodeâ†’data.
• If the value of level is even and the value of the current node is odd, find the nearest even perfect square and update temp_nodeâ†’data.
• Otherwise, find the nearest odd perfect square if the value of level is odd or the closest even perfect square if the value of level is even. Update temp_nodeâ†’data.
• Print temp_nodeâ†’data.
• Enqueue temp_nodeâ€™s children (first left, then right child) to q, if exists.
• Dequeue current node from q.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach``#include ``using` `namespace` `std;` `// Structure of a``// Binary Tree Node``struct` `Node {``    ``int` `data;``    ``struct` `Node *left, *right;``};` `// Function to replace all nodes``// at even and odd levels with their``// nearest even or odd perfect squares``void` `LevelOrderTraversal(Node* root)``{``    ``// Base Case``    ``if` `(root == NULL)``        ``return``;` `    ``// Create an empty queue``    ``// for level order traversal``    ``queue q;` `    ``// Enqueue root``    ``q.push(root);` `    ``// Initialize height``    ``int` `lvl = 1;` `    ``// Iterate until queue is not empty``    ``while` `(q.empty() == ``false``) {` `        ``// Store the size``        ``// of the queue``        ``int` `n = q.size();` `        ``// Traverse in range [1, n]``        ``for` `(``int` `i = 0; i < n; i++) {` `            ``// Store the current node``            ``Node* node = q.front();` `            ``// Store its square root``            ``double` `num = ``sqrt``(node->data);``            ``int` `x1 = ``floor``(num);``            ``int` `x2 = ``ceil``(num);` `            ``// Check if it is a perfect square``            ``if` `(x1 == x2) {` `                ``// If level is odd and value is even,``                ``// find the closest odd perfect square``                ``if` `((lvl & 1) && !(x1 & 1)) {` `                    ``int` `num1 = x1 - 1, num2 = x1 + 1;` `                    ``node->data``                        ``= (``abs``(node->data - num1 * num1)``                           ``< ``abs``(node->data - num2 * num2))``                              ``? (num1 * num1)``                              ``: (num2 * num2);``                ``}` `                ``// If level is even and value is odd,``                ``// find the closest even perfect square``                ``if` `(!(lvl & 1) && (x1 & 1)) {` `                    ``int` `num1 = x1 - 1, num2 = x1 + 1;` `                    ``node->data``                        ``= (``abs``(node->data - num1 * num1)``                           ``< ``abs``(node->data - num2 * num2))``                              ``? (num1 * num1)``                              ``: (num2 * num2);``                ``}``            ``}` `            ``// Otherwise, find the find``            ``// the nearest perfect square``            ``else` `{``                ``if` `(lvl & 1)``                    ``node->data``                        ``= (x1 & 1) ? (x1 * x1) : (x2 * x2);``                ``else``                    ``node->data``                        ``= (x1 & 1) ? (x2 * x2) : (x1 * x1);``            ``}` `            ``// Print front of queue``            ``// and remove it from queue``            ``cout << node->data << ``" "``;``            ``q.pop();` `            ``// Enqueue left child``            ``if` `(node->left != NULL)``                ``q.push(node->left);` `            ``// Enqueue right child``            ``if` `(node->right != NULL)``                ``q.push(node->right);``        ``}` `        ``// Increment the level by 1``        ``lvl++;``        ``cout << endl;``    ``}``}` `// Utility function to``// create a new tree node``Node* newNode(``int` `data)``{``    ``Node* temp = ``new` `Node;``    ``temp->data = data;``    ``temp->left = temp->right = NULL;``    ``return` `temp;``}` `// Driver Code``int` `main()``{``    ``// Binary Tree``    ``Node* root = newNode(5);``    ``root->left = newNode(3);``    ``root->right = newNode(2);``    ``root->right->left = newNode(16);``    ``root->right->right = newNode(19);` `    ``LevelOrderTraversal(root);` `    ``return` `0;``}`

## Java

 `// Java program for the above approach``import` `java.io.*;``import` `java.util.*;` `// Structure of a``// Binary Tree Node``class` `Node``{``    ``int` `data;``    ``Node left, right;``    ` `    ``Node(``int` `data)``    ``{``        ``this``.data = data;``        ``left = right = ``null``;``    ``}``}` `class` `GFG{``    ` `// Function to replace all nodes``// at even and odd levels with their``// nearest even or odd perfect squares``static` `void` `LevelOrderTraversal(Node root)``{``    ` `    ``// Base Case``    ``if` `(root == ``null``)``        ``return``;``    ` `    ``// Create an empty queue``    ``// for level order traversal``    ``Queue q = ``new` `LinkedList<>();``    ` `    ``// Enqueue root``    ``q.add(root);``    ` `    ``// Initialize height``    ``int` `lvl = ``1``;``    ` `    ``// Iterate until queue is not empty``    ``while` `(q.size() != ``0``)``    ``{``        ` `        ``// Store the size``        ``// of the queue``        ``int` `n = q.size();`` ` `        ``// Traverse in range [1, n]``        ``for``(``int` `i = ``0``; i < n; i++)``        ``{``            ` `            ``// Store the current node``            ``Node node = q.peek();`` ` `            ``// Store its square root``            ``double` `num = Math.sqrt(node.data);``            ``int` `x1 = (``int``)Math.floor(num);``            ``int` `x2 = (``int``)Math.ceil(num);`` ` `            ``// Check if it is a perfect square``            ``if` `(x1 == x2)``            ``{``                ` `                ``// If level is odd and value is even,``                ``// find the closest odd perfect square``                ``if` `(((lvl & ``1``) != ``0``) && !((x1 & ``1``) != ``0``))``                ``{``                    ``int` `num1 = x1 - ``1``, num2 = x1 + ``1``;`` ` `                    ``node.data = (Math.abs(node.data - num1 * num1) <``                                 ``Math.abs(node.data - num2 * num2)) ?``                                 ``(num1 * num1) : (num2 * num2);``                ``}`` ` `                ``// If level is even and value is odd,``                ``// find the closest even perfect square``                ``if` `(!((lvl & ``1``) != ``0``) && ((x1 & ``1``) != ``0``))``                ``{``                    ``int` `num1 = x1 - ``1``, num2 = x1 + ``1``;`` ` `                    ``node.data = (Math.abs(node.data - num1 * num1) <``                                 ``Math.abs(node.data - num2 * num2)) ?``                                 ``(num1 * num1) : (num2 * num2);``                ``}``            ``}`` ` `            ``// Otherwise, find the find``            ``// the nearest perfect square``            ``else``            ``{``                ``if` `((lvl & ``1``) != ``0``)``                    ``node.data = (x1 & ``1``) != ``0` `?``                                ``(x1 * x1) : (x2 * x2);``                ``else``                    ``node.data = (x1 & ``1``) != ``0` `?``                                ``(x2 * x2) : (x1 * x1);``            ``}`` ` `            ``// Print front of queue``            ``// and remove it from queue``            ``System.out.print(node.data + ``" "``);``            ``q.poll();`` ` `            ``// Enqueue left child``            ``if` `(node.left != ``null``)``                ``q.add(node.left);`` ` `            ``// Enqueue right child``            ``if` `(node.right != ``null``)``                ``q.add(node.right);``        ``}`` ` `        ``// Increment the level by 1``        ``lvl++;``        ``System.out.println();``    ``}``}` `// Driver Code``public` `static` `void` `main (String[] args)``{``    ` `    ``// Binary Tree``    ``Node root = ``new` `Node(``5``);``    ``root.left = ``new` `Node(``3``);``    ``root.right = ``new` `Node(``2``);``    ``root.right.left = ``new` `Node(``16``);``    ``root.right.right = ``new` `Node(``19``);` `    ``LevelOrderTraversal(root);``}``}` `// This code is contributed by avanitrachhadiya2155`

## Python3

 `# Python3 program for the above approach``from` `collections ``import` `deque``from` `math ``import` `sqrt, ceil, floor` `# Structure of a``# Binary Tree Node``class` `Node:``    ``def` `__init__(``self``, x):``        ``self``.data ``=` `x``        ``self``.left ``=` `None``        ``self``.right ``=` `None` `# Function to replace all nodes``# at even and odd levels with their``# nearest even or odd perfect squares``def` `LevelOrderTraversal(root):``  ` `    ``# Base Case``    ``if` `(root ``=``=` `None``):``        ``return` `    ``# Create an empty queue``    ``# for level order traversal``    ``q ``=` `deque()` `    ``# Enqueue root``    ``q.append(root)` `    ``# Initialize height``    ``lvl ``=` `1` `    ``# Iterate until queue is not empty``    ``while` `(``len``(q) > ``0``):` `        ``# Store the size``        ``# of the queue``        ``n ``=` `len``(q)` `        ``# Traverse in range [1, n]``        ``for` `i ``in` `range``(n):` `            ``# Store the current node``            ``node ``=` `q.popleft()` `            ``# Store its square root``            ``num ``=` `sqrt(node.data)``            ``x1 ``=` `floor(num)``            ``x2 ``=` `ceil(num)` `            ``# Check if it is a perfect square``            ``if` `(x1 ``=``=` `x2):` `                ``# If level is odd and value is even,``                ``# find the closest odd perfect square``                ``if` `((lvl & ``1``) ``and` `not` `(x1 & ``1``)):``                    ``num1, num2 ``=` `x1 ``-` `1``, x1 ``+` `1``                    ``node.data ``=` `(num1 ``*` `num1) ``if` `(``abs``(node.data ``-` `num1 ``*` `num1) < ``abs``(node.data ``-` `num2 ``*` `num2)) ``else` `(num2 ``*` `num2)` `                ``# If level is even and value is odd,``                ``# find the closest even perfect square``                ``if` `(``not` `(lvl & ``1``) ``and` `(x1 & ``1``)):``                    ``num1,num2 ``=` `x1 ``-` `1``, x1 ``+` `1``                    ``node.data ``=` `(num1 ``*` `num1) ``if` `(``abs``(node.data ``-` `num1 ``*` `num1) < ``abs``(node.data ``-` `num2 ``*` `num2)) ``else` `(num2 ``*` `num2)` `            ``# Otherwise, find the find``            ``# the nearest perfect square``            ``else``:``                ``if` `(lvl & ``1``):``                    ``node.data ``=` `(x1 ``*` `x1) ``if` `(x1 & ``1``) ``else` `(x2 ``*` `x2)``                ``else``:``                    ``node.data ``=` `(x2 ``*` `x2) ``if` `(x1 & ``1``) ``else` `(x1 ``*` `x1)` `            ``# Prfront of queue``            ``# and remove it from queue``            ``print``(node.data, end ``=` `" "``)` `            ``# Enqueue left child``            ``if` `(node.left !``=` `None``):``                ``q.append(node.left)` `            ``# Enqueue right child``            ``if` `(node.right !``=` `None``):``                ``q.append(node.right)` `        ``# Increment the level by 1``        ``lvl ``+``=` `1``        ``print``()` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``  ` `    ``# Binary Tree``    ``root ``=` `Node(``5``)``    ``root.left ``=` `Node(``3``)``    ``root.right ``=` `Node(``2``)``    ``root.right.left ``=` `Node(``16``)``    ``root.right.right ``=` `Node(``19``)` `    ``LevelOrderTraversal(root)` `    ``# This code is contributed by mohit kumar 29.`

## C#

 `// C# program for the above approach``using` `System;``using` `System.Collections.Generic;` `// Structure of a``// Binary Tree Node``public` `class` `Node``{``  ``public` `int` `data;``  ``public` `Node left, right;` `  ``public` `Node(``int` `data)``  ``{``    ``this``.data = data;``    ``left = right = ``null``;``  ``}``}` `public` `class` `GFG``{` `  ``// Function to replace all nodes``  ``// at even and odd levels with their``  ``// nearest even or odd perfect squares``  ``static` `void` `LevelOrderTraversal(Node root)``  ``{` `    ``// Base Case``    ``if` `(root == ``null``)``      ``return``;` `    ``// Create an empty queue``    ``// for level order traversal``    ``Queue q = ``new` `Queue();` `    ``// Enqueue root``    ``q.Enqueue(root);` `    ``// Initialize height``    ``int` `lvl = 1;` `    ``// Iterate until queue is not empty``    ``while` `(q.Count != 0)``    ``{` `      ``// Store the size``      ``// of the queue``      ``int` `n = q.Count;` `      ``// Traverse in range [1, n]``      ``for``(``int` `i = 0; i < n; i++)``      ``{` `        ``// Store the current node``        ``Node node = q.Peek();` `        ``// Store its square root``        ``double` `num = Math.Sqrt(node.data);``        ``int` `x1 = (``int``)Math.Floor(num);``        ``int` `x2 = (``int``)Math.Ceiling(num);` `        ``// Check if it is a perfect square``        ``if` `(x1 == x2)``        ``{` `          ``// If level is odd and value is even,``          ``// find the closest odd perfect square``          ``if` `(((lvl & 1) != 0) && !((x1 & 1) != 0))``          ``{``            ``int` `num1 = x1 - 1, num2 = x1 + 1;` `            ``node.data = (Math.Abs(node.data - num1 * num1) <``                         ``Math.Abs(node.data - num2 * num2)) ?``              ``(num1 * num1) : (num2 * num2);``          ``}` `          ``// If level is even and value is odd,``          ``// find the closest even perfect square``          ``if` `(!((lvl & 1) != 0) && ((x1 & 1) != 0))``          ``{``            ``int` `num1 = x1 - 1, num2 = x1 + 1;` `            ``node.data = (Math.Abs(node.data - num1 * num1) <``                         ``Math.Abs(node.data - num2 * num2)) ?``              ``(num1 * num1) : (num2 * num2);``          ``}``        ``}` `        ``// Otherwise, find the find``        ``// the nearest perfect square``        ``else``        ``{``          ``if` `((lvl & 1) != 0)``            ``node.data = (x1 & 1) != 0 ?``            ``(x1 * x1) : (x2 * x2);``          ``else``            ``node.data = (x1 & 1) != 0 ?``            ``(x2 * x2) : (x1 * x1);``        ``}` `        ``// Print front of queue``        ``// and remove it from queue``        ``Console.Write(node.data + ``" "``);``        ``q.Dequeue();` `        ``// Enqueue left child``        ``if` `(node.left != ``null``)``          ``q.Enqueue(node.left);` `        ``// Enqueue right child``        ``if` `(node.right != ``null``)``          ``q.Enqueue(node.right);``      ``}` `      ``// Increment the level by 1``      ``lvl++;``      ``Console.WriteLine();``    ``}``  ``}` `  ``// Driver Code``  ``static` `public` `void` `Main ()``  ``{` `    ``// Binary Tree``    ``Node root = ``new` `Node(5);``    ``root.left = ``new` `Node(3);``    ``root.right = ``new` `Node(2);``    ``root.right.left = ``new` `Node(16);``    ``root.right.right = ``new` `Node(19);` `    ``LevelOrderTraversal(root);``  ``}``}` `// This code is contributed by rag2127`

## Javascript

 ``

Output:

```9
4 4
9 25```

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

My Personal Notes arrow_drop_up