 GFG App
Open App Browser
Continue

# Foldable Binary Trees

Given a binary tree, find out if the tree can be folded or not. A tree can be folded if the left and right subtrees of the tree are structure-wise mirror images of each other. An empty tree is considered foldable.

Examples:

Input:
10
/     \
7      15
\     /
9  11
Output: Can be folded

Input:
10
/  \
7   15
/    /
5   11
Output: Cannot be folded

## Foldable Binary Trees by Changing Left Subtree to its Mirror:

The idea is to change the left subtree to its mirror then check that left subtree with its right subtree.

Follow the steps below to solve the problem:

1. If tree is empty, then return true.
2. Convert the left subtree to its mirror image
3. Check if the structure of left subtree and right subtree is same and store the result.
• res = isStructSame(root->left, root->right). isStructSame() recursively compares structures of two subtrees and returns true if structures are same
4. Revert the changes made in step (2) to get the original tree.
5. Return result res stored in step 3.

Below is the implementation of the above approach.

## C++

 `// C++ program to check foldable binary tree` `#include ` `using` `namespace` `std;`   `/* You would want to remove below` `3 lines if your compiler supports` `bool, true and false */`   `/* A binary tree node has data,` `pointer to left child and a` `pointer to right child */` `class` `node {` `public``:` `    ``int` `data;` `    ``node* left;` `    ``node* right;` `};`   `/* converts a tree to its mirror image */` `void` `mirror(node* node);`   `/* returns true if structure of` `two trees a and b is same only` `structure is considered for comparison, not data! */` `bool` `isStructSame(node* a, node* b);`   `/* Returns true if the given tree is foldable */` `bool` `isFoldable(node* root)` `{` `    ``bool` `res;`   `    ``/* base case */` `    ``if` `(root == NULL)` `        ``return` `true``;`   `    ``/* convert left subtree to its mirror */` `    ``mirror(root->left);`   `    ``/* Compare the structures of the` `    ``right subtree and mirrored` `    ``left subtree */` `    ``res = isStructSame(root->left, root->right);`   `    ``/* Get the original tree back */` `    ``mirror(root->left);`   `    ``return` `res;` `}`   `bool` `isStructSame(node* a, node* b)` `{` `    ``if` `(a == NULL && b == NULL) {` `        ``return` `true``;` `    ``}` `    ``if` `(a != NULL && b != NULL` `        ``&& isStructSame(a->left, b->left)` `        ``&& isStructSame(a->right, b->right)) {` `        ``return` `true``;` `    ``}`   `    ``return` `false``;` `}`   `/* UTILITY FUNCTIONS */` `/* Change a tree so that the roles of the left and` `    ``right pointers are swapped at every node.` `    ``See https:// www.geeksforgeeks.org/?p=662 for details */` `void` `mirror(node* Node)` `{` `    ``if` `(Node == NULL)` `        ``return``;` `    ``else` `{` `        ``node* temp;`   `        ``/* do the subtrees */` `        ``mirror(Node->left);` `        ``mirror(Node->right);`   `        ``/* swap the pointers in this node */` `        ``temp = Node->left;` `        ``Node->left = Node->right;` `        ``Node->right = temp;` `    ``}` `}`   `/* Helper function that allocates a new node with the` `given data and NULL left and right pointers. */` `node* newNode(``int` `data)` `{` `    ``node* Node = ``new` `node();` `    ``Node->data = data;` `    ``Node->left = NULL;` `    ``Node->right = NULL;`   `    ``return` `(Node);` `}`   `/* Driver program to test mirror() */` `int` `main(``void``)` `{` `    ``/* The constructed binary tree is` `            ``1` `        ``/ \` `        ``2 3` `        ``\ /` `        ``4 5` `    ``*/` `    ``node* root = newNode(1);` `    ``root->left = newNode(2);` `    ``root->right = newNode(3);` `    ``root->left->right = newNode(4);` `    ``root->right->left = newNode(5);`   `    ``if` `(isFoldable(root) == 1) {` `        ``cout << ``"tree is foldable"``;` `    ``}` `    ``else` `{` `        ``cout << ``"\ntree is not foldable"``;` `    ``}` `    ``return` `0;` `}`   `// This code is contributed by rathbhupendra`

## C

 `#include ` `#include `   `/* You would want to remove below 3 lines if your compiler` `   ``supports bool, true and false */` `#define bool int` `#define true 1` `#define false 0`   `/* A binary tree node has data, pointer to left child` `   ``and a pointer to right child */` `struct` `node {` `    ``int` `data;` `    ``struct` `node* left;` `    ``struct` `node* right;` `};`   `/* converts a tree to its mirror image */` `void` `mirror(``struct` `node* node);`   `/* returns true if structure of two trees a and b is same` `   ``Only structure is considered for comparison, not data! */` `bool` `isStructSame(``struct` `node* a, ``struct` `node* b);`   `/* Returns true if the given tree is foldable */` `bool` `isFoldable(``struct` `node* root)` `{` `    ``bool` `res;`   `    ``/* base case */` `    ``if` `(root == NULL)` `        ``return` `true``;`   `    ``/* convert left subtree to its mirror */` `    ``mirror(root->left);`   `    ``/* Compare the structures of the right subtree and` `    ``mirrored left subtree */` `    ``res = isStructSame(root->left, root->right);`   `    ``/* Get the original tree back */` `    ``mirror(root->left);`   `    ``return` `res;` `}`   `bool` `isStructSame(``struct` `node* a, ``struct` `node* b)` `{` `    ``if` `(a == NULL && b == NULL) {` `        ``return` `true``;` `    ``}` `    ``if` `(a != NULL && b != NULL` `        ``&& isStructSame(a->left, b->left)` `        ``&& isStructSame(a->right, b->right)) {` `        ``return` `true``;` `    ``}`   `    ``return` `false``;` `}`   `/* UTILITY FUNCTIONS */` `/* Change a tree so that the roles of the  left and` `    ``right pointers are swapped at every node.` `    ``See https:// www.geeksforgeeks.org/?p=662 for details */` `void` `mirror(``struct` `node* node)` `{` `    ``if` `(node == NULL)` `        ``return``;` `    ``else` `{` `        ``struct` `node* temp;`   `        ``/* do the subtrees */` `        ``mirror(node->left);` `        ``mirror(node->right);`   `        ``/* swap the pointers in this node */` `        ``temp = node->left;` `        ``node->left = node->right;` `        ``node->right = temp;` `    ``}` `}`   `/* Helper function that allocates a new node with the` `   ``given data and NULL left and right pointers. */` `struct` `node* newNode(``int` `data)` `{` `    ``struct` `node* node` `        ``= (``struct` `node*)``malloc``(``sizeof``(``struct` `node));` `    ``node->data = data;` `    ``node->left = NULL;` `    ``node->right = NULL;`   `    ``return` `(node);` `}`   `/* Driver program to test mirror() */` `int` `main(``void``)` `{` `    ``/* The constructed binary tree is` `         ``1` `       ``/   \` `      ``2     3` `      ``\    /` `       ``4  5` `  ``*/` `    ``struct` `node* root = newNode(1);` `    ``root->left = newNode(2);` `    ``root->right = newNode(3);` `    ``root->right->left = newNode(4);` `    ``root->left->right = newNode(5);`   `    ``if` `(isFoldable(root) == 1) {` `        ``printf``(``"\n tree is foldable"``);` `    ``}` `    ``else` `{` `        ``printf``(``"\n tree is not foldable"``);` `    ``}`   `    ``getchar``();` `    ``return` `0;` `}`

## Java

 `// Java program to check foldable binary tree`   `/* A binary tree node has data, pointer to left child` `   ``and a pointer to right child */` `class` `Node {` `    ``int` `data;` `    ``Node left, right;`   `    ``Node(``int` `item)` `    ``{` `        ``data = item;` `        ``left = right = ``null``;` `    ``}` `}`   `class` `BinaryTree {` `    ``Node root;`   `    ``/* Returns true if the given tree is foldable */` `    ``boolean` `isFoldable(Node node)` `    ``{` `        ``boolean` `res;`   `        ``/* base case */` `        ``if` `(node == ``null``)` `            ``return` `true``;`   `        ``/* convert left subtree to its mirror */` `        ``mirror(node.left);`   `        ``/* Compare the structures of the right subtree and` `         ``mirrored left subtree */` `        ``res = isStructSame(node.left, node.right);`   `        ``/* Get the original tree back */` `        ``mirror(node.left);`   `        ``return` `res;` `    ``}`   `    ``boolean` `isStructSame(Node a, Node b)` `    ``{` `        ``if` `(a == ``null` `&& b == ``null``)` `            ``return` `true``;` `        ``if` `(a != ``null` `&& b != ``null` `            ``&& isStructSame(a.left, b.left)` `            ``&& isStructSame(a.right, b.right))` `            ``return` `true``;`   `        ``return` `false``;` `    ``}`   `    ``/* UTILITY FUNCTIONS */`   `    ``/* Change a tree so that the roles of the  left and` `       ``right pointers are swapped at every node.` `       ``See https:// www.geeksforgeeks.org/?p=662 for details` `     ``*/` `    ``void` `mirror(Node node)` `    ``{` `        ``if` `(node == ``null``)` `            ``return``;` `        ``else` `{` `            ``Node temp;`   `            ``/* do the subtrees */` `            ``mirror(node.left);` `            ``mirror(node.right);`   `            ``/* swap the pointers in this node */` `            ``temp = node.left;` `            ``node.left = node.right;` `            ``node.right = temp;` `        ``}` `    ``}`   `    ``/* Driver program to test above functions */` `    ``public` `static` `void` `main(String args[])` `    ``{` `        ``BinaryTree tree = ``new` `BinaryTree();`   `        ``/* The constructed binary tree is` `             ``1` `           ``/   \` `          ``2     3` `           ``\    /` `            ``4  5` `        ``*/` `        ``tree.root = ``new` `Node(``1``);` `        ``tree.root.left = ``new` `Node(``2``);` `        ``tree.root.right = ``new` `Node(``3``);` `        ``tree.root.right.left = ``new` `Node(``4``);` `        ``tree.root.left.right = ``new` `Node(``5``);`   `        ``if` `(tree.isFoldable(tree.root))` `            ``System.out.println(``"tree is foldable"``);` `        ``else` `            ``System.out.println(``"Tree is not foldable"``);` `    ``}` `}`   `// This code has been contributed by Mayank Jaiswal`

## Python3

 `# Python3 program to check foldable binary tree`   `#  A binary tree node has data,` `# pointer to left child and a` `# pointer to right child`     `class` `newNode:` `    ``def` `__init__(``self``, d):` `        ``self``.data ``=` `d` `        ``self``.left ``=` `None` `        ``self``.right ``=` `None`   `# Returns true if the given` `# tree is foldable`     `def` `isFoldable(node):`   `    ``# base case` `    ``if` `node ``=``=` `None``:` `        ``return` `true`   `    ``# convert left subtree to its mirror` `    ``mirror(node.left)`   `    ``# Compare the structures of the right subtree and mirrored` `    ``# left subtree` `    ``res ``=` `isStructSame(node.left, node.right)`   `    ``# Get the original tree back` `    ``mirror(node.left)`   `    ``return` `res`     `def` `isStructSame(a, b):`   `    ``if` `a ``=``=` `None` `and` `b ``=``=` `None``:` `        ``return` `True` `    ``if` `a !``=` `None` `and` `b !``=` `None` `and` `isStructSame(a.left, b.left) ``and` `isStructSame(a.right, b.right):` `        ``return` `True`   `    ``return` `False`     `def` `mirror(node):`   `    ``if` `node ``=``=` `None``:` `        ``return` `    ``else``:`   `        ``# do the subtrees` `        ``mirror(node.left)` `        ``mirror(node.right)`   `        ``# swap the pointers in this node` `        ``temp ``=` `node.left` `        ``node.left ``=` `node.right` `        ``node.right ``=` `temp`     `# Driver Code` `if` `__name__ ``=``=` `'__main__'``:`   `    ``''' ` `    ``The constructed binary tree is` `             ``1` `           ``/   \` `          ``2     3` `           ``\    /` `            ``4  5` `    ``'''` `    ``root ``=` `newNode(``1``)` `    ``root.left ``=` `newNode(``2``)` `    ``root.right ``=` `newNode(``3``)` `    ``root.right.left ``=` `newNode(``4``)` `    ``root.left.right ``=` `newNode(``5``)`   `    ``if` `isFoldable(root):` `        ``print``(``"tree is foldable"``)` `    ``else``:` `        ``print``(``"Tree is not foldable"``)`

## C#

 `// C# program to check foldable` `// binary tree` `using` `System;`   `/* A binary tree node has data,` `pointer to left child and` `a pointer to right child */` `class` `Node {` `    ``public` `int` `data;` `    ``public` `Node left, right;`   `    ``public` `Node(``int` `item)` `    ``{` `        ``data = item;` `        ``left = right = ``null``;` `    ``}` `}`   `class` `BinaryTree {` `    ``Node root;`   `    ``/* Returns true if the given` `   ``tree is foldable */` `    ``Boolean isFoldable(Node node)` `    ``{` `        ``Boolean res;`   `        ``/* base case */` `        ``if` `(node == ``null``)` `            ``return` `true``;`   `        ``/* convert left subtree` `       ``to its mirror */` `        ``mirror(node.left);`   `        ``/* Compare the structures of the` `       ``right subtree and mirrored` `       ``left subtree */` `        ``res = isStructSame(node.left, node.right);`   `        ``/* Get the original tree back */` `        ``mirror(node.left);`   `        ``return` `res;` `    ``}`   `    ``Boolean isStructSame(Node a, Node b)` `    ``{` `        ``if` `(a == ``null` `&& b == ``null``)` `            ``return` `true``;` `        ``if` `(a != ``null` `&& b != ``null` `            ``&& isStructSame(a.left, b.left)` `            ``&& isStructSame(a.right, b.right))` `            ``return` `true``;`   `        ``return` `false``;` `    ``}`   `    ``/* UTILITY FUNCTIONS */`   `    ``/* Change a tree so that the roles` `of the left and right pointers are` `swapped at every node.` `See https:// www.geeksforgeeks.org/?p=662` `for details */` `    ``void` `mirror(Node node)` `    ``{` `        ``if` `(node == ``null``)` `            ``return``;` `        ``else` `{` `            ``Node temp;`   `            ``/* do the subtrees */` `            ``mirror(node.left);` `            ``mirror(node.right);`   `            ``/* swap the pointers in this node */` `            ``temp = node.left;` `            ``node.left = node.right;` `            ``node.right = temp;` `        ``}` `    ``}`   `    ``// Driver Code` `    ``static` `public` `void` `Main(String[] args)` `    ``{` `        ``BinaryTree tree = ``new` `BinaryTree();`   `        ``/* The constructed binary tree is` `                    ``1` `                 ``/     \` `                ``2        3` `                 ``\     /` `                 ``4    5` `    ``*/` `        ``tree.root = ``new` `Node(1);` `        ``tree.root.left = ``new` `Node(2);` `        ``tree.root.right = ``new` `Node(3);` `        ``tree.root.right.left = ``new` `Node(4);` `        ``tree.root.left.right = ``new` `Node(5);`   `        ``if` `(tree.isFoldable(tree.root))` `            ``Console.WriteLine(``"tree is foldable"``);` `        ``else` `            ``Console.WriteLine(``"Tree is not foldable"``);` `    ``}` `}`   `// This code is contributed by Arnab Kundu`

## Javascript

 ``

Output

`tree is foldable`

Time complexity: O(N), Visiting all the nodes of the tree of size N.
Auxiliary Space: O(N), If stack space is considered else O(1)

Thanks to ajaym for suggesting this approach.

## Foldable Binary Trees by Checking if Left and Right subtrees are Mirror:

The idea is to check the left and right subtree whether they are mirror or not.

Follow the steps below to solve the problem:

• If tree is empty then return true.
• Else check if left and right subtrees are structure wise mirrors of each other. Use utility function IsFoldableUtil(root->left, root->right) for this.
• Checks if n1 and n2 are mirror of each other.
• If both trees are empty then return true.
• If one of them is empty and other is not then return false.
• Return true if following conditions are met
• n1->left is mirror of n2->right
• n1->right is mirror of n2->left

Below is the implementation of the above approach.

## C++

 `#include ` `using` `namespace` `std;`   `/* You would want to remove below 3 lines if your compiler` `supports bool, true and false */`   `/* A binary tree node has data, pointer to left child` `and a pointer to right child */` `class` `node {` `public``:` `    ``int` `data;` `    ``node* left;` `    ``node* right;` `};`   `/* A utility function that checks` `if trees with roots as n1 and n2` `are mirror of each other */` `bool` `IsFoldableUtil(node* n1, node* n2);`   `/* Returns true if the given tree can be folded */` `bool` `IsFoldable(node* root)` `{` `    ``if` `(root == NULL) {` `        ``return` `true``;` `    ``}`   `    ``return` `IsFoldableUtil(root->left, root->right);` `}`   `/* A utility function that checks` `if trees with roots as n1 and n2` `are mirror of each other */` `bool` `IsFoldableUtil(node* n1, node* n2)` `{` `    ``/* If both left and right subtrees are NULL,` `    ``then return true */` `    ``if` `(n1 == NULL && n2 == NULL) {` `        ``return` `true``;` `    ``}`   `    ``/* If one of the trees is NULL and other is not,` `    ``then return false */` `    ``if` `(n1 == NULL || n2 == NULL) {` `        ``return` `false``;` `    ``}`   `    ``/* Otherwise check if left and right subtrees are` `    ``mirrors of their counterparts */` `    ``return` `IsFoldableUtil(n1->left, n2->right)` `           ``&& IsFoldableUtil(n1->right, n2->left);` `}`   `/*UTILITY FUNCTIONS */` `/* Helper function that allocates a new node with the` `given data and NULL left and right pointers. */` `node* newNode(``int` `data)` `{` `    ``node* Node = ``new` `node();` `    ``Node->data = data;` `    ``Node->left = NULL;` `    ``Node->right = NULL;`   `    ``return` `(Node);` `}`   `/* Driver code */` `int` `main(``void``)` `{` `    ``/* The constructed binary tree is` `        ``1` `        ``/ \` `        ``2 3` `        ``\ /` `        ``4 5` `    ``*/` `    ``node* root = newNode(1);` `    ``root->left = newNode(2);` `    ``root->right = newNode(3);` `    ``root->left->right = newNode(4);` `    ``root->right->left = newNode(5);`   `    ``if` `(IsFoldable(root) == ``true``) {` `        ``cout << ``"tree is foldable"``;` `    ``}` `    ``else` `{` `        ``cout << ``"tree is not foldable"``;` `    ``}`   `    ``return` `0;` `}`   `// This is code is contributed by rathbhupendra`

## C

 `#include ` `#include `   `/* You would want to remove below 3 lines if your compiler` `   ``supports bool, true and false */` `#define bool int` `#define true 1` `#define false 0`   `/* A binary tree node has data, pointer to left child` `   ``and a pointer to right child */` `struct` `node {` `    ``int` `data;` `    ``struct` `node* left;` `    ``struct` `node* right;` `};`   `/* A utility function that checks if trees with roots as n1` `  ``and n2 are mirror of each other */` `bool` `IsFoldableUtil(``struct` `node* n1, ``struct` `node* n2);`   `/* Returns true if the given tree can be folded */` `bool` `IsFoldable(``struct` `node* root)` `{` `    ``if` `(root == NULL) {` `        ``return` `true``;` `    ``}`   `    ``return` `IsFoldableUtil(root->left, root->right);` `}`   `/* A utility function that checks if trees with roots as n1` `  ``and n2 are mirror of each other */` `bool` `IsFoldableUtil(``struct` `node* n1, ``struct` `node* n2)` `{` `    ``/* If both left and right subtrees are NULL,` `      ``then return true */` `    ``if` `(n1 == NULL && n2 == NULL) {` `        ``return` `true``;` `    ``}`   `    ``/* If one of the trees is NULL and other is not,` `      ``then return false */` `    ``if` `(n1 == NULL || n2 == NULL) {` `        ``return` `false``;` `    ``}`   `    ``/* Otherwise check if left and right subtrees are` `       ``mirrors of their counterparts */` `    ``return` `IsFoldableUtil(n1->left, n2->right)` `           ``&& IsFoldableUtil(n1->right, n2->left);` `}`   `/*UTILITY FUNCTIONS */` `/* Helper function that allocates a new node with the` `   ``given data and NULL left and right pointers. */` `struct` `node* newNode(``int` `data)` `{` `    ``struct` `node* node` `        ``= (``struct` `node*)``malloc``(``sizeof``(``struct` `node));` `    ``node->data = data;` `    ``node->left = NULL;` `    ``node->right = NULL;`   `    ``return` `(node);` `}`   `/* Driver program to test mirror() */` `int` `main(``void``)` `{` `    ``/* The constructed binary tree is` `         ``1` `       ``/   \` `      ``2     3` `      ``\    /` `       ``4  5` `  ``*/` `    ``struct` `node* root = newNode(1);` `    ``root->left = newNode(2);` `    ``root->right = newNode(3);` `    ``root->left->right = newNode(4);` `    ``root->right->left = newNode(5);`   `    ``if` `(IsFoldable(root) == ``true``) {` `        ``printf``(``"\n tree is foldable"``);` `    ``}` `    ``else` `{` `        ``printf``(``"\n tree is not foldable"``);` `    ``}`   `    ``getchar``();` `    ``return` `0;` `}`

## Java

 `// Java program to check foldable binary tree`   `/* A binary tree node has data, pointer to left child` `   ``and a pointer to right child */` `class` `Node {` `    ``int` `data;` `    ``Node left, right;`   `    ``Node(``int` `item)` `    ``{` `        ``data = item;` `        ``left = right = ``null``;` `    ``}` `}`   `class` `BinaryTree {` `    ``Node root;`   `    ``/* Returns true if the given tree can be folded */` `    ``boolean` `IsFoldable(Node node)` `    ``{` `        ``if` `(node == ``null``)` `            ``return` `true``;`   `        ``return` `IsFoldableUtil(node.left, node.right);` `    ``}`   `    ``/* A utility function that checks if trees with roots as` `     ``n1 and n2 are mirror of each other */` `    ``boolean` `IsFoldableUtil(Node n1, Node n2)` `    ``{`   `        ``/* If both left and right subtrees are NULL,` `         ``then return true */` `        ``if` `(n1 == ``null` `&& n2 == ``null``)` `            ``return` `true``;`   `        ``/* If one of the trees is NULL and other is not,` `         ``then return false */` `        ``if` `(n1 == ``null` `|| n2 == ``null``)` `            ``return` `false``;`   `        ``/* Otherwise check if left and right subtrees are` `         ``mirrors of their counterparts */` `        ``return` `IsFoldableUtil(n1.left, n2.right)` `            ``&& IsFoldableUtil(n1.right, n2.left);` `    ``}`   `    ``/* Driver program to test above functions */` `    ``public` `static` `void` `main(String args[])` `    ``{` `        ``BinaryTree tree = ``new` `BinaryTree();`   `        ``/* The constructed binary tree is` `             ``1` `           ``/   \` `          ``2     3` `           ``\    /` `            ``4  5` `        ``*/` `        ``tree.root = ``new` `Node(``1``);` `        ``tree.root.left = ``new` `Node(``2``);` `        ``tree.root.right = ``new` `Node(``3``);` `        ``tree.root.right.left = ``new` `Node(``4``);` `        ``tree.root.left.right = ``new` `Node(``5``);`   `        ``if` `(tree.IsFoldable(tree.root))` `            ``System.out.println(``"tree is foldable"``);` `        ``else` `            ``System.out.println(``"Tree is not foldable"``);` `    ``}` `}`   `// This code has been contributed by Mayank Jaiswal`

## Python3

 `# Python3 program to check` `# foldable binary tree`   `# Utility function to create a new` `# tree node`     `class` `newNode:` `    ``def` `__init__(``self``, data):` `        ``self``.data ``=` `data` `        ``self``.left ``=` `self``.right ``=` `None`   `# Returns true if the given tree can be folded`     `def` `IsFoldable(root):` `    ``if` `(root ``=``=` `None``):` `        ``return` `True` `    ``return` `IsFoldableUtil(root.left, root.right)`     `# A utility function that checks` `# if trees with roots as n1 and n2` `# are mirror of each other` `def` `IsFoldableUtil(n1, n2):` `    ``# If both left and right subtrees are NULL,` `    ``# then return true` `    ``if` `n1 ``=``=` `None` `and` `n2 ``=``=` `None``:` `        ``return` `True`   `    ``# If one of the trees is NULL and other is not,` `    ``# then return false` `    ``if` `n1 ``=``=` `None` `or` `n2 ``=``=` `None``:` `        ``return` `False`   `    ``# Otherwise check if left and` `    ``# right subtrees are mirrors of` `    ``# their counterparts`   `    ``d1 ``=` `IsFoldableUtil(n1.left, n2.right)` `    ``d2 ``=` `IsFoldableUtil(n1.right, n2.left)` `    ``return` `d1 ``and` `d2`     `# Driver code` `if` `__name__ ``=``=` `"__main__"``:`   `    ``""" The constructed binary tree is  ` `    ``1  ` `    ``/ \  ` `    ``2 3  ` `    ``\ /  ` `    ``4 5  ` `"""` `    ``root ``=` `newNode(``1``)` `    ``root.left ``=` `newNode(``2``)` `    ``root.right ``=` `newNode(``3``)` `    ``root.left.right ``=` `newNode(``4``)` `    ``root.right.left ``=` `newNode(``5``)`   `    ``if` `IsFoldable(root):` `        ``print``(``"tree is foldable"``)` `    ``else``:` `        ``print``(``"tree is not foldable"``)`   `# This code is contributed by` `# Anupam Baranwal(anupambaranwal)`

## C#

 `// C# program to check foldable binary tree` `using` `System;`   `/* A binary tree node has data, pointer to left child` `and a pointer to right child */` `public` `class` `Node {` `    ``public` `int` `data;` `    ``public` `Node left, right;`   `    ``public` `Node(``int` `item)` `    ``{` `        ``data = item;` `        ``left = right = ``null``;` `    ``}` `}`   `public` `class` `BinaryTree {` `    ``Node root;`   `    ``/* Returns true if the given tree can be folded */` `    ``bool` `IsFoldable(Node node)` `    ``{` `        ``if` `(node == ``null``)` `            ``return` `true``;`   `        ``return` `IsFoldableUtil(node.left, node.right);` `    ``}`   `    ``/* A utility function that checks if` `    ``trees with roots as n1 and n2` `    ``are mirror of each other */` `    ``bool` `IsFoldableUtil(Node n1, Node n2)` `    ``{`   `        ``/* If both left and right subtrees are NULL,` `        ``then return true */` `        ``if` `(n1 == ``null` `&& n2 == ``null``)` `            ``return` `true``;`   `        ``/* If one of the trees is NULL and other is not,` `        ``then return false */` `        ``if` `(n1 == ``null` `|| n2 == ``null``)` `            ``return` `false``;`   `        ``/* Otherwise check if left and right subtrees are` `        ``mirrors of their counterparts */` `        ``return` `IsFoldableUtil(n1.left, n2.right)` `            ``&& IsFoldableUtil(n1.right, n2.left);` `    ``}`   `    ``/* Driver code */` `    ``public` `static` `void` `Main(String[] args)` `    ``{` `        ``BinaryTree tree = ``new` `BinaryTree();`   `        ``/* The constructed binary tree is` `            ``1` `        ``/ \` `        ``2     3` `        ``\ /` `            ``4 5` `        ``*/` `        ``tree.root = ``new` `Node(1);` `        ``tree.root.left = ``new` `Node(2);` `        ``tree.root.right = ``new` `Node(3);` `        ``tree.root.right.left = ``new` `Node(4);` `        ``tree.root.left.right = ``new` `Node(5);`   `        ``if` `(tree.IsFoldable(tree.root))` `            ``Console.WriteLine(``"tree is foldable"``);` `        ``else` `            ``Console.WriteLine(``"Tree is not foldable"``);` `    ``}` `}`   `/* This code contributed by PrinciRaj1992 */`

## Javascript

 ``

Output

`tree is foldable`

Time Complexity: O(N), Visiting every node of the tree of size N.
Auxiliary Space: O(N), If stack space is considered

## Foldable Binary Trees using Breadth first Search:

The idea is to use Queue for traversing the tree and using the BFS approach.

Follow the steps below to solve the problem:

• The left child of the left subtree = the right child of the right subtree. Both of them should be not null.
• The right child of the left subtree = left child of the right subtree. Both of them should be null or not null.

Below is the implementation of the above approach:

## C++

 `// CPP code for above approach` `#include ` `using` `namespace` `std;`   `// Class Node to store the data and left and right` `// pointers` `class` `Node` `{` `public``:` `    ``int` `key;` `    ``Node *left;` `    ``Node *right;`   `    ``Node(``int` `key)` `    ``{` `        ``this``->key = key;` `        ``left = right = NULL;` `    ``}` `};`   `class` `FoldableTrees` `{` `public``:` `    ``Node *root = NULL;`   `    ``// Function to find whether the tree is foldable` `    ``bool` `isFoldable()` `    ``{`   `        ``// Queue to store visited nodes` `        ``queue q;`   `        ``// Initially add the left and right nodes of root` `        ``if` `(root != NULL)` `        ``{` `            ``q.push(root->left);` `            ``q.push(root->right);` `        ``}`   `        ``while` `(!q.empty())` `        ``{`   `            ``// Remove the front 2 nodes to` `            ``// check for null condition` `            ``Node *p = q.front();` `            ``q.pop();` `            ``Node *r = q.front();` `            ``q.pop();`   `            ``// If both are null, continue and check` `            ``// the further elements` `            ``if` `(p == NULL && r == NULL)` `                ``continue``;`   `            ``// If one of them is not null, then return false` `            ``if` `((p == NULL && r != NULL) || (p != NULL && r == NULL))` `                ``return` `false``;`   `            ``/* Insert in the same order:` `            ``1. left of left subtree` `            ``2. right of right subtree` `            ``3.right of left subtree` `            ``4.left of right subtree */` `            ``q.push(p->left);` `            ``q.push(r->right);` `            ``q.push(p->right);` `            ``q.push(r->left);` `        ``}`   `        ``// Only if the tree is foldable` `        ``return` `true``;` `    ``}`   `    ``// Driver code` `};`   `int` `main()` `{` `    ``FoldableTrees tree = FoldableTrees();`   `    ``// Insert data into the tree` `    ``tree.root = ``new` `Node(1);` `    ``tree.root->left = ``new` `Node(2);` `    ``tree.root->right = ``new` `Node(3);` `    ``tree.root->right->left = ``new` `Node(4);` `    ``tree.root->left->right = ``new` `Node(5);`   `    ``// Function call` `    ``if` `(tree.isFoldable())` `        ``cout << ``"tree is foldable"` `<< endl;` `    ``else` `        ``cout << ``"tree is not foldable"` `<< endl;` `}`   `// This code is contributed by adityamaharshi21`

## Java

 `// Java code for the above approach`   `import` `java.util.LinkedList;` `import` `java.util.Queue;`   `public` `class` `FoldableTrees {` `    ``Node root = ``null``;`   `    `  `    ``class` `Node {` `        ``int` `key;` `        ``Node left;` `        ``Node right;`   `        ``Node(``int` `key)` `        ``{` `            ``this``.key = key;` `            ``left = right = ``null``;` `        ``}` `    ``}`   `    ``// Function to find whether the tree is foldable` `    ``boolean` `isFoldable()` `    ``{`   `        ``// Queue to store visited nodes` `        ``Queue q = ``new` `LinkedList<>();`   `        ``// Initially add the left and right nodes of root` `        ``if` `(root != ``null``) {` `            ``q.add(root.left);` `            ``q.add(root.right);` `        ``}`   `        ``while` `(!q.isEmpty()) {`   `            ``// Remove the front 2 nodes to` `            ``// check for null condition` `            ``Node p = q.remove();` `            ``Node r = q.remove();`   `            ``// If both are null, continue and check` `            ``// the further elements` `            ``if` `(p == ``null` `&& r == ``null``)` `                ``continue``;`   `            ``// If one of them is not null, then return false` `            ``if` `((p == ``null` `&& r != ``null``)` `                ``|| (p != ``null` `&& r == ``null``))` `                ``return` `false``;`   `            ``/* Insert in the same order:` `              ``1. left of left subtree` `              ``2. right of right subtree` `              ``3.right of left subtree` `              ``4.left of right subtree  */` `            ``q.add(p.left);` `            ``q.add(r.right);` `            ``q.add(p.right);` `            ``q.add(r.left);` `        ``}`   `        ``// Only if the tree is foldable` `        ``return` `true``;` `    ``}`   `    ``// Driver code` `    ``public` `static` `void` `main(String args[])` `    ``{` `        ``FoldableTrees tree = ``new` `FoldableTrees();`   `        ``// Insert data into the tree` `        ``tree.root = tree.``new` `Node(``1``);` `        ``tree.root.left = tree.``new` `Node(``2``);` `        ``tree.root.right = tree.``new` `Node(``3``);` `        ``tree.root.right.left = tree.``new` `Node(``4``);` `        ``tree.root.left.right = tree.``new` `Node(``5``);`   `        ``// Function call` `        ``if` `(tree.isFoldable())` `            ``System.out.println(``"tree is foldable"``);` `        ``else` `            ``System.out.println(``"tree is not foldable"``);` `    ``}` `}`   `// This method is contributed by likhita AVL`

## Python3

 `# class to create a node with key, left child and right child.` `class` `Node:` `    ``def` `__init__(``self``, key):` `        ``self``.key ``=` `key` `        ``self``.left ``=` `None` `        ``self``.right ``=` `None`     `# Function to find whether the tree is foldable` `def` `isFoldable(root):`   `     ``# Queue to store visited nodes` `    ``q ``=` `[]`   `    ``# Initially add the left and right nodes of root` `    ``if` `root !``=` `None``:` `        ``q.append(root.left)` `        ``q.append(root.right)`   `    ``while` `(``len``(q) !``=` `0``):`   `        ``# Remove the front 2 nodes to` `        ``# check for None condition` `        ``p ``=` `q.pop(``0``)` `        ``r ``=` `q.pop(``0``)`   `        ``# If both are None, continue and check` `        ``# the further elements` `        ``if` `(p ``=``=` `None` `and` `r ``=``=` `None``):` `            ``continue`   `        ``# If one of them is not None, then return False` `        ``if` `((p ``=``=` `None` `and` `r !``=` `None``) ``or` `(p !``=` `None` `and` `r ``=``=` `None``)):` `            ``return` `False`   `        ``''' Insert in the same order:` `            ``1. left of left subtree` `            ``2. right of right subtree` `            ``3. right of left subtree` `            ``4. left of right subtree  ` `        ``'''` `        ``q.append(p.left)` `        ``q.append(r.right)` `        ``q.append(p.right)` `        ``q.append(r.left)`   `    ``# Only if the tree is foldable` `    ``return` `True`     `# Driver code` `# Insert data into the tree` `root ``=` `Node(``1``)` `root.left ``=` `Node(``2``)` `root.right ``=` `Node(``3``)` `root.right.left ``=` `Node(``4``)` `root.left.right ``=` `Node(``5``)`   `# Function call` `if` `isFoldable(root):` `    ``print``(``"tree is foldable"``)` `else``:` `    ``print``(``"tree is not foldable"``)`   `    ``# This code is contributed by mariuscristiancapatina`

## C#

 `using` `System;` `using` `System.Collections.Generic;`   `public` `class` `Node {` `    ``public` `int` `key;` `    ``public` `Node left, right;`   `    ``public` `Node(``int` `key)` `    ``{` `        ``this``.key = key;` `        ``this``.left = ``this``.right = ``null``;` `    ``}` `}`   `public` `class` `FoldableTrees {` `    ``Node root = ``null``;`   `    ``// Function to find whether the tree is foldable` `    ``bool` `isFoldable()` `    ``{`   `        ``// Queue to store visited nodes` `        ``Queue q = ``new` `Queue();`   `        ``// Initially add the left and right nodes of root` `        ``if` `(root != ``null``) {` `            ``q.Enqueue(root.left);` `            ``q.Enqueue(root.right);` `        ``}`   `        ``while` `(q.Count != 0) {`   `            ``// Remove the front 2 nodes to` `            ``// check for null condition` `            ``Node p = q.Dequeue();` `            ``Node r = q.Dequeue();`   `            ``// If both are null, continue and check` `            ``// the further elements` `            ``if` `(p == ``null` `&& r == ``null``)` `                ``continue``;`   `            ``// If one of them is not null, then return false` `            ``if` `((p == ``null` `&& r != ``null``)` `                ``|| (p != ``null` `&& r == ``null``))` `                ``return` `false``;`   `            ``/* Insert in the same order:` `              ``1. left of left subtree` `              ``2. right of right subtree` `              ``3.right of left subtree` `              ``4.left of right subtree  */` `            ``q.Enqueue(p.left);` `            ``q.Enqueue(r.right);` `            ``q.Enqueue(p.right);` `            ``q.Enqueue(r.left);` `        ``}`   `        ``// Only if the tree is foldable` `        ``return` `true``;` `    ``}`   `    ``// Driver code` `    ``static` `public` `void` `Main()` `    ``{` `        ``FoldableTrees tree = ``new` `FoldableTrees();`   `        ``// Insert data into the tree` `        ``tree.root = ``new` `Node(1);` `        ``tree.root.left = ``new` `Node(2);` `        ``tree.root.right = ``new` `Node(3);` `        ``tree.root.right.left = ``new` `Node(4);` `        ``tree.root.left.right = ``new` `Node(5);`   `        ``// Function call` `        ``if` `(tree.isFoldable())` `            ``Console.WriteLine(``"tree is foldable"``);` `        ``else` `            ``Console.WriteLine(``"tree is not foldable"``);` `    ``}` `}`   `// This code is contributed by patel2127.`

## Javascript

 ``

Output

`tree is foldable`

Time complexity: O(N), Visiting all the nodes of the tree of size N.
Auxiliary Space: O(N), Using queue for storing nodes

Please write comments if you find the above code/algorithm incorrect, or find other ways to solve the same problem.

My Personal Notes arrow_drop_up