GFG App
Open App
Browser
Continue

# Print all Palindromic Levels Of a Binary Tree

Given a Binary Tree, the task is to print all palindromic levels of this tree.

Palindrome Level Any level of a Binary tree is said to be a palindromic level if on traversing it from left to right, the result is same as traversing that level from right to left.

Examples:

```Input:
1
/  \
12    13
/     /   \
11    6     11
\    /
2   2
Output:
1
11 6 11
2 2
Explanation:
First, third and fourth levels are palindrome.

Input:
7
/  \
22      22
/  \      \
3     6     3
/ \     \    /
1   5     8   1
/
23
Output:
7
22 22
3 6 3
23

Explanation:
First, second, third and fifth levels are palindrome.```

Approach: In order to check if each level is a Palindromic level, we need to first do the Level Order Traversal of the Binary tree to get the values at each level. Then for each level, check if it a palindrome or not.
Here a Queue data structure is used to store the levels of the Tree while doing the Level Order Traversal.

Below is the implementation of the above approach:

## C++

 `// C++ program for printing a` `// Palindromic Levels of Binary Tree`   `#include ` `using` `namespace` `std;`   `// A Tree node` `struct` `Node {` `    ``int` `key;` `    ``struct` `Node *left, *right;` `};`   `// Utility function to create a new node` `Node* newNode(``int` `key)` `{` `    ``Node* temp = ``new` `Node;` `    ``temp->key = key;` `    ``temp->left = temp->right = NULL;` `    ``return` `(temp);` `}`   `// Function to print a Palindromic level` `void` `printLevel(``struct` `Node* queue[],` `                ``int` `index, ``int` `size)` `{` `    ``for` `(``int` `i = index; i < size; i++) {` `        ``cout << queue[i]->key << ``" "``;` `    ``}`   `    ``cout << endl;` `}`   `// Function to check whether given level` `// is Palindromic level or not` `bool` `isPalindrome(``struct` `Node* queue[],` `                  ``int` `index, ``int` `size)` `{`   `    ``while` `(index < size) {` `        ``// check value of two nodes are` `        ``// equal or not` `        ``if` `(queue[index++]->key` `            ``!= queue[size--]->key)` `            ``return` `false``;` `    ``}`   `    ``return` `true``;` `}`   `// Utility function to get palindromic` `// level of a given Binary tree` `void` `printPalLevel(``struct` `Node* node,` `                   ``struct` `Node* queue[],` `                   ``int` `index, ``int` `size)` `{`   `    ``// Print root node value` `    ``// as a single value in a` `    ``// level is also a Palindrome` `    ``cout << queue[index]->key << endl;`   `    ``// Level order traversal of Tree` `    ``while` `(index < size) {` `        ``int` `curr_size = size;` `        ``while` `(index < curr_size) {` `            ``struct` `Node* temp = queue[index];`   `            ``if` `(temp->left != NULL) {` `                ``queue[size++] = temp->left;` `            ``}`   `            ``if` `(temp->right != NULL) {` `                ``queue[size++] = temp->right;` `            ``}`   `            ``index++;` `        ``}`   `        ``// Check if level is Palindrome or not` `        ``if` `(isPalindrome(queue, index, size - 1)) {` `            ``printLevel(queue, index, size);` `        ``}` `    ``}` `}`   `// Function to find total no of nodes` `int` `findSize(``struct` `Node* node)` `{`   `    ``if` `(node == NULL)` `        ``return` `0;`   `    ``return` `1` `           ``+ findSize(node->left)` `           ``+ findSize(node->right);` `}`   `// Function to find palindromic level` `// In a given binary tree` `void` `printPalindromicLevel(``struct` `Node* node)` `{` `    ``int` `t_size = findSize(node);` `    ``struct` `Node* queue[t_size];` `    ``queue[0] = node;` `    ``printPalLevel(node, queue, 0, 1);` `}`   `// Driver Code` `int` `main()` `{` `    ``/*     10 ` `        ``/    \ ` `       ``13     13 ` `        ``/       \ ` `        ``14        15 ` `        ``/ \        / \ ` `       ``21 22      22 21` `                     ``/` `                    ``8 */`   `    ``// Create Binary Tree as shown` `    ``Node* root = newNode(10);` `    ``root->left = newNode(13);` `    ``root->right = newNode(13);`   `    ``root->right->left = newNode(14);` `    ``root->right->right = newNode(15);`   `    ``root->right->left->left = newNode(21);` `    ``root->right->left->right = newNode(22);` `    ``root->right->right->left = newNode(22);` `    ``root->right->right->right = newNode(21);` `    ``root->right->right->right->left = newNode(8);`   `    ``// Print Palindromic Levels` `    ``printPalindromicLevel(root);`   `    ``return` `0;` `}`

## Java

 `// Java program for printing a` `// Palindromic Levels of Binary Tree` `class` `GFG{` ` `  `// A Tree node` `static` `class` `Node {` `    ``int` `key;` `    ``Node left, right;` `};` ` `  `// Utility function to create a new node` `static` `Node newNode(``int` `key)` `{` `    ``Node temp = ``new` `Node();` `    ``temp.key = key;` `    ``temp.left = temp.right = ``null``;` `    ``return` `(temp);` `}` ` `  `// Function to print a Palindromic level` `static` `void` `printLevel(Node queue[],` `                ``int` `index, ``int` `size)` `{` `    ``for` `(``int` `i = index; i < size; i++) {` `        ``System.out.print(queue[i].key+ ``" "``);` `    ``}` ` `  `    ``System.out.println();` `}` ` `  `// Function to check whether given level` `// is Palindromic level or not` `static` `boolean` `isPalindrome(Node queue[],` `                  ``int` `index, ``int` `size)` `{` ` `  `    ``while` `(index < size) {` `        ``// check value of two nodes are` `        ``// equal or not` `        ``if` `(queue[index++].key` `            ``!= queue[size--].key)` `            ``return` `false``;` `    ``}` ` `  `    ``return` `true``;` `}` ` `  `// Utility function to get palindromic` `// level of a given Binary tree` `static` `void` `printPalLevel(Node node,` `                   ``Node queue[],` `                   ``int` `index, ``int` `size)` `{` ` `  `    ``// Print root node value` `    ``// as a single value in a` `    ``// level is also a Palindrome` `    ``System.out.print(queue[index].key +``"\n"``);` ` `  `    ``// Level order traversal of Tree` `    ``while` `(index < size) {` `        ``int` `curr_size = size;` `        ``while` `(index < curr_size) {` `            ``Node temp = queue[index];` ` `  `            ``if` `(temp.left != ``null``) {` `                ``queue[size++] = temp.left;` `            ``}` ` `  `            ``if` `(temp.right != ``null``) {` `                ``queue[size++] = temp.right;` `            ``}` ` `  `            ``index++;` `        ``}` ` `  `        ``// Check if level is Palindrome or not` `        ``if` `(isPalindrome(queue, index, size - ``1``)) {` `            ``printLevel(queue, index, size);` `        ``}` `    ``}` `}` ` `  `// Function to find total no of nodes` `static` `int` `findSize(Node node)` `{` ` `  `    ``if` `(node == ``null``)` `        ``return` `0``;` ` `  `    ``return` `1` `           ``+ findSize(node.left)` `           ``+ findSize(node.right);` `}` ` `  `// Function to find palindromic level` `// In a given binary tree` `static` `void` `printPalindromicLevel(Node node)` `{` `    ``int` `t_size = findSize(node);` `    ``Node []queue = ``new` `Node[t_size];` `    ``queue[``0``] = node;` `    ``printPalLevel(node, queue, ``0``, ``1``);` `}` ` `  `// Driver Code` `public` `static` `void` `main(String[] args)` `{` `    ``/*     10 ` `        ``/    \ ` `       ``13     13 ` `        ``/       \ ` `        ``14        15 ` `        ``/ \        / \ ` `       ``21 22      22 21` `                     ``/` `                    ``8 */` ` `  `    ``// Create Binary Tree as shown` `    ``Node root = newNode(``10``);` `    ``root.left = newNode(``13``);` `    ``root.right = newNode(``13``);` ` `  `    ``root.right.left = newNode(``14``);` `    ``root.right.right = newNode(``15``);` ` `  `    ``root.right.left.left = newNode(``21``);` `    ``root.right.left.right = newNode(``22``);` `    ``root.right.right.left = newNode(``22``);` `    ``root.right.right.right = newNode(``21``);` `    ``root.right.right.right.left = newNode(``8``);` ` `  `    ``// Print Palindromic Levels` `    ``printPalindromicLevel(root);` ` `  `}` `}`   `// This code is contributed by Rajput-Ji`

## Python3

 `# Python3 program for printing a` `# Palindromic Levels of Binary Tree`   `# A BST node` `class` `Node:` `    `  `    ``def` `__init__(``self``, x):` `        `  `        ``self``.key ``=` `x` `        ``self``.left ``=` `None` `        ``self``.right ``=` `None`   `# Function to print a Palindromic level` `def` `printLevel(queue, index, size):` `    `  `    ``for` `i ``in` `range``(index, size):` `        ``print``(queue[i].key, end ``=` `" "``)` `        `  `    ``print``()`   `# Function to check whether given level` `# is Palindromic level or not` `def` `isPalindrome(queue, index, size):` `    `  `    ``#print(index,size)`   `    ``while` `(index < size):` `        `  `        ``# Check value of two nodes are` `        ``# equal or not` `        ``if` `(queue[index].key !``=` `queue[size].key):` `            ``return` `False` `            `  `        ``index ``+``=` `1` `        ``size ``-``=` `1`   `    ``return` `True`   `# Utility function to get palindromic` `# level of a given Binary tree` `def` `printPalLevel(node, queue, index, size):` `    `  `    ``# Print root node value` `    ``# as a single value in a` `    ``# level is also a Palindrome` `    ``print``(queue[index].key)`   `    ``# Level order traversal of Tree` `    ``while` `(index < size):` `        ``curr_size ``=` `size` `        `  `        ``while` `(index < curr_size):` `            ``temp ``=` `queue[index]` `            `  `            ``if` `(temp.left !``=` `None``):` `                ``queue[size] ``=` `temp.left` `                ``size ``+``=` `1`   `            ``if` `(temp.right !``=` `None``):` `                ``queue[size] ``=` `temp.right` `                ``size ``+``=` `1`   `            ``index ``+``=` `1`   `        ``# Check if level is Palindrome or not` `        ``if` `(isPalindrome(queue, index, size ``-` `1``) ``=``=` `True``):` `            ``printLevel(queue, index, size)`   `# Function to find total no of nodes` `def` `findSize(node):`   `    ``if` `(node ``=``=` `None``):` `        ``return` `0`   `    ``return` `(``1` `+` `findSize(node.left) ``+` `                ``findSize(node.right))`   `# Function to find palindromic level` `# In a given binary tree` `def` `printPalindromicLevel(node):` `    `  `    ``t_size ``=` `findSize(node)` `    ``queue ``=` `[``None` `for` `i ``in` `range``(t_size)]` `    ``queue[``0``] ``=` `node` `    ``printPalLevel(node, queue, ``0``, ``1``)`   `# Driver Code` `if` `__name__ ``=``=` `'__main__'``:` `    `  `    ``#       10` `    ``#     /    \` `    ``#    13     13` `    ``#     /       \` `    ``#     14        15` `    ``#     / \        / \` `    ``#    21 22      22 21` `    ``#                  /` `    ``#                 8 `   `    ``# Create Binary Tree as shown` `    ``root ``=` `Node(``10``)` `    ``root.left ``=` `Node(``13``)` `    ``root.right ``=` `Node(``13``)`   `    ``root.right.left ``=` `Node(``14``)` `    ``root.right.right ``=` `Node(``15``)`   `    ``root.right.left.left ``=` `Node(``21``)` `    ``root.right.left.right ``=` `Node(``22``)` `    ``root.right.right.left ``=` `Node(``22``)` `    ``root.right.right.right ``=` `Node(``21``)` `    ``root.right.right.right.left ``=` `Node(``8``)`   `    ``# Print Palindromic Levels` `    ``printPalindromicLevel(root)`   `# This code is contributed by mohit kumar 29`

## C#

 `// C# program for printing a` `// Palindromic Levels of Binary Tree` `using` `System;`   `class` `GFG{` `  `  `// A Tree node` `class` `Node {` `    ``public` `int` `key;` `    ``public` `Node left, right;` `};` `  `  `// Utility function to create a new node` `static` `Node newNode(``int` `key)` `{` `    ``Node temp = ``new` `Node();` `    ``temp.key = key;` `    ``temp.left = temp.right = ``null``;` `    ``return` `(temp);` `}` `  `  `// Function to print a Palindromic level` `static` `void` `printLevel(Node []queue,` `                ``int` `index, ``int` `size)` `{` `    ``for` `(``int` `i = index; i < size; i++) {` `        ``Console.Write(queue[i].key+ ``" "``);` `    ``}` `  `  `    ``Console.WriteLine();` `}` `  `  `// Function to check whether given level` `// is Palindromic level or not` `static` `bool` `isPalindrome(Node []queue,` `                  ``int` `index, ``int` `size)` `{` `  `  `    ``while` `(index < size) {` `        ``// check value of two nodes are` `        ``// equal or not` `        ``if` `(queue[index++].key` `            ``!= queue[size--].key)` `            ``return` `false``;` `    ``}` `  `  `    ``return` `true``;` `}` `  `  `// Utility function to get palindromic` `// level of a given Binary tree` `static` `void` `printPalLevel(Node node,` `                   ``Node []queue,` `                   ``int` `index, ``int` `size)` `{` `  `  `    ``// Print root node value` `    ``// as a single value in a` `    ``// level is also a Palindrome` `    ``Console.Write(queue[index].key +``"\n"``);` `  `  `    ``// Level order traversal of Tree` `    ``while` `(index < size) {` `        ``int` `curr_size = size;` `        ``while` `(index < curr_size) {` `            ``Node temp = queue[index];` `  `  `            ``if` `(temp.left != ``null``) {` `                ``queue[size++] = temp.left;` `            ``}` `  `  `            ``if` `(temp.right != ``null``) {` `                ``queue[size++] = temp.right;` `            ``}` `  `  `            ``index++;` `        ``}` `  `  `        ``// Check if level is Palindrome or not` `        ``if` `(isPalindrome(queue, index, size - 1)) {` `            ``printLevel(queue, index, size);` `        ``}` `    ``}` `}` `  `  `// Function to find total no of nodes` `static` `int` `findSize(Node node)` `{` `  `  `    ``if` `(node == ``null``)` `        ``return` `0;` `  `  `    ``return` `1` `           ``+ findSize(node.left)` `           ``+ findSize(node.right);` `}` `  `  `// Function to find palindromic level` `// In a given binary tree` `static` `void` `printPalindromicLevel(Node node)` `{` `    ``int` `t_size = findSize(node);` `    ``Node []queue = ``new` `Node[t_size];` `    ``queue[0] = node;` `    ``printPalLevel(node, queue, 0, 1);` `}` `  `  `// Driver Code` `public` `static` `void` `Main(String[] args)` `{` `    ``/*     10 ` `        ``/    \ ` `       ``13     13 ` `        ``/       \ ` `        ``14        15 ` `        ``/ \        / \ ` `       ``21 22      22 21` `                     ``/` `                    ``8 */` `  `  `    ``// Create Binary Tree as shown` `    ``Node root = newNode(10);` `    ``root.left = newNode(13);` `    ``root.right = newNode(13);` `  `  `    ``root.right.left = newNode(14);` `    ``root.right.right = newNode(15);` `  `  `    ``root.right.left.left = newNode(21);` `    ``root.right.left.right = newNode(22);` `    ``root.right.right.left = newNode(22);` `    ``root.right.right.right = newNode(21);` `    ``root.right.right.right.left = newNode(8);` `  `  `    ``// Print Palindromic Levels` `    ``printPalindromicLevel(root);` `  `  `}` `}` ` `  `// This code is contributed by sapnasingh4991`

## Javascript

 ``

Output

```10
13 13
21 22 22 21
8

```

Time Complexity: time complexity of this code is O(n^2), as the isPalindrome function takes O(n) time to check whether the current level is a palindrome or not, and this function is called for every level of the tree. The total number of levels in the tree is equal to the height of the tree, which is also O(n) in the worst case. Therefore, the overall time complexity is O(n^2).

Auxiliary Space: O(n), as the size of the queue array, is equal to the total number of nodes in the binary tree. This is because the queue array is used to store the nodes during the level order traversal of the tree.

My Personal Notes arrow_drop_up