Symmetric Tree (Mirror Image of itself)

Foldable Binary Trees

Last Updated : 06 Nov, 2024

Try it on GfG Practice

Given a binary tree, the task is to 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:

Output: True
Explanation: The above tree can be folded as left and right subtrees of the tree are structure-wise mirror images of each other.
Input:

Output: False
Explanation: The above tree cannot be folded as left and right subtrees of the tree are not structure-wise mirror images of each other.

Table of Content

[Expected Approach - 1] By Changing Left Subtree to its Mirror - O(n) Time and O(h) Space
[Expected Approach - 2] By Comparing Subtree Nodes Recursively - O(n) Time and O(h) Space
[Expected Approach - 3] Using Breadth first Search - O(n) Time and O(n) Space

[Expected Approach - 1] By Changing Left Subtree to its Mirror - O(n) Time and O(h) Space

The idea is to change the left subtree to its mirror then compare the left subtree with the right subtree. First, convert the left subtree to its mirror image (for each node, swap its left and right nodes). Then compare the structure of left subtree and right subtree and store the result. Revert the left subtree and return the result.

C++

// C++ program to check foldable binary tree
#include <bits/stdc++.h>
using namespace std;

class Node {
public:
    int data;
    Node *left, *right;
    Node (int x) {
        data = x;
        left = nullptr;
        right = nullptr;
    }
};

// Function to convert subtree 
// into its mirror 
void mirror(Node* root) {
    if (root == nullptr) return;

    // Recursively process the left
    // and right subtrees.
    mirror(root->left);
    mirror(root->right);

    // swap the left and right nodes.
    Node* temp = root->left;
    root->left = root->right;
    root->right = temp;
}

// function to check if two trees have
// same structure
bool isStructSame(Node* a, Node* b) {
    
    // If both subtrees are null, return 
    // true.
    if (a == nullptr && b == nullptr)
        return true;
        
    // If one of the subtrees is null,
    // return false.
    if (a == nullptr || b == nullptr) 
        return false;
    
    // check left and right subtree.    
    return isStructSame(a->left, b->left) 
    &&
    isStructSame(a->right, b->right);
}

// Function to check if a tree is foldable.
bool isFoldable(Node* root) {
    if (root == nullptr) 
        return true;
        
    // Convert left subtree into 
    // its mirror.
    mirror(root->left);
    
    // Compare the left subtree 
    // and right subtree.
    bool ans = isStructSame(root->left, root->right);
    
    // Revert the left subtree.
    mirror(root->left);
    
    return ans;
}

int main() {
    
    // The constructed binary tree is
    //      1
    //     / \
    //     2 3
    //     \ /
    //     4 5
    Node* root = new Node(1);
    root->left = new Node(2);
    root->right = new Node(3);
    root->left->right = new Node(4);
    root->right->left = new Node(5);

    if (isFoldable(root)) {
        cout << "True" << endl;
    } else {
        cout << "False" << endl;
    }
    return 0;
}

C

// C program to check foldable binary tree
#include <stdio.h>
#include <stdlib.h>

struct Node {
    int data;
    struct Node* left;
    struct Node* right;
};

// Function to convert subtree 
// into its mirror 
void mirror(struct Node* root) {
    if (root == NULL) return;

    // Recursively process the left
    // and right subtrees.
    mirror(root->left);
    mirror(root->right);

    // swap the left and right nodes.
    struct Node* temp = root->left;
    root->left = root->right;
    root->right = temp;
}

// function to check if two trees have
// same structure
int isStructSame(struct Node* a, struct Node* b) {

    // If both subtrees are null, return 
    // true.
    if (a == NULL && b == NULL)
        return 1;

    // If one of the subtrees is null,
    // return false.
    if (a == NULL || b == NULL)
        return 0;

    // check left and right subtree.    
    return isStructSame(a->left, b->left) 
    && 
    isStructSame(a->right, b->right);
}

// Function to check if a tree is foldable.
int isFoldable(struct Node* root) {
    if (root == NULL)
        return 1;

    // Convert left subtree into 
    // its mirror.
    mirror(root->left);

    // Compare the left subtree 
    // and right subtree.
    int ans = isStructSame(root->left, root->right);

    // Revert the left subtree.
    mirror(root->left);

    return ans;
}

struct Node* createNode(int x) {
    struct Node* newNode = 
    	(struct Node*)malloc(sizeof(struct Node));
    newNode->data = x;
    newNode->left = NULL;
    newNode->right = NULL;
    return newNode;
}

int main() {

    // The constructed binary tree is
    //      1
    //     / \
    //     2  3
    //     \  /
    //     4 5
    struct Node* root = createNode(1);
    root->left = createNode(2);
    root->right = createNode(3);
    root->left->right = createNode(4);
    root->right->left = createNode(5);

    if (isFoldable(root)) {
        printf("True\n");
    } else {
        printf("False\n");
    }

    return 0;
}

Java

// Java program to check foldable binary tree
class Node {
    int data;
    Node left, right;

    Node(int x) {
        data = x;
        left = null;
        right = null;
    }
}

class GfG {

    // Function to convert subtree 
    // into its mirror 
    static void mirror(Node root) {
        if (root == null) return;

        // Recursively process the left
        // and right subtrees.
        mirror(root.left);
        mirror(root.right);

        // swap the left and right nodes.
        Node temp = root.left;
        root.left = root.right;
        root.right = temp;
    }

    // function to check if two trees have
    // same structure
    static boolean isStructSame(Node a, Node b) {

        // If both subtrees are null, return 
        // true.
        if (a == null && b == null)
            return true;

        // If one of the subtrees is null,
        // return false.
        if (a == null || b == null)
            return false;

        // check left and right subtree.    
        return isStructSame(a.left, b.left)
            && 
            isStructSame(a.right, b.right);
    }

    // Function to check if a tree is foldable.
    static boolean isFoldable(Node root) {
        if (root == null)
            return true;

        // Convert left subtree into 
        // its mirror.
        mirror(root.left);

        // Compare the left subtree 
        // and right subtree.
        boolean ans = isStructSame(root.left, root.right);

        // Revert the left subtree.
        mirror(root.left);

        return ans;
    }

    public static void main(String[] args) {

        // The constructed binary tree is
        //      1
        //     / \
        //     2  3
        //     \  /
        //     4 5
        Node root = new Node(1);
        root.left = new Node(2);
        root.right = new Node(3);
        root.left.right = new Node(4);
        root.right.left = new Node(5);

        if (isFoldable(root)) {
            System.out.println("True");
        } else {
            System.out.println("False");
        }
    }
}

Python

# Python program to check foldable binary tree

class Node:
    def __init__(self, x):
        self.data = x
        self.left = None
        self.right = None

# Function to convert subtree 
# into its mirror 
def mirror(root):
    if root is None:
        return

    # Recursively process the left
    # and right subtrees.
    mirror(root.left)
    mirror(root.right)

    # swap the left and right nodes.
    root.left, root.right = root.right, root.left

# function to check if two trees have
# same structure
def isStructSame(a, b):
    
    # If both subtrees are null, return 
    # true.
    if a is None and b is None:
        return True
    
    # If one of the subtrees is null,
    # return false.
    if a is None or b is None:
        return False
    
    # check left and right subtree.
    return isStructSame(a.left, b.left) and \
  	isStructSame(a.right, b.right)

# Function to check if a tree is foldable.
def isFoldable(root):
    if root is None:
        return True

    # Convert left subtree into 
    # its mirror.
    mirror(root.left)

    # Compare the left subtree 
    # and right subtree.
    ans = isStructSame(root.left, root.right)

    # Revert the left subtree.
    mirror(root.left)

    return ans

if __name__ == "__main__":

    # The constructed binary tree is
    #      1
    #     / \
    #     2  3
    #     \  /
    #     4 5
    root = Node(1)
    root.left = Node(2)
    root.right = Node(3)
    root.left.right = Node(4)
    root.right.left = Node(5)

    if isFoldable(root):
        print("True")
    else:
        print("False")

C#

// C# program to check foldable binary tree
using System;

class Node {
    public int data;
    public Node left, right;

    public Node(int x) {
        data = x;
        left = null;
        right = null;
    }
}

class GfG {

    // Function to convert subtree 
    // into its mirror 
    static void Mirror(Node root) {
        if (root == null) return;

        // Recursively process the left
        // and right subtrees.
        Mirror(root.left);
        Mirror(root.right);

        // swap the left and right nodes.
        Node temp = root.left;
        root.left = root.right;
        root.right = temp;
    }

    // function to check if two trees have
    // same structure
    static bool IsStructSame(Node a, Node b) {

        // If both subtrees are null, return 
        // true.
        if (a == null && b == null)
            return true;

        // If one of the subtrees is null,
        // return false.
        if (a == null || b == null)
            return false;

        // check left and right subtree.    
        return IsStructSame(a.left, b.left)
            && 
            IsStructSame(a.right, b.right);
    }

    // Function to check if a tree is foldable.
    static bool isFoldable(Node root) {
        if (root == null)
            return true;

        // Convert left subtree into 
        // its mirror.
        Mirror(root.left);

        // Compare the left subtree 
        // and right subtree.
        bool ans = IsStructSame(root.left, root.right);

        // Revert the left subtree.
        Mirror(root.left);

        return ans;
    }

    static void Main() {

        // The constructed binary tree is
        //      1
        //     / \
        //     2  3
        //     \  /
        //     4 5
        Node root = new Node(1);
        root.left = new Node(2);
        root.right = new Node(3);
        root.left.right = new Node(4);
        root.right.left = new Node(5);

        if (isFoldable(root)) {
            Console.WriteLine("True");
        } else {
            Console.WriteLine("False");
        }
    }
}

JavaScript

// JavaScript program to check foldable binary tree

class Node {
    constructor(x) {
        this.data = x;
        this.left = null;
        this.right = null;
    }
}

// Function to convert subtree 
// into its mirror 
function mirror(root) {
    if (root === null) return;

    // Recursively process the left
    // and right subtrees.
    mirror(root.left);
    mirror(root.right);

    // swap the left and right nodes.
    let temp = root.left;
    root.left = root.right;
    root.right = temp;
}

// function to check if two trees have
// same structure
function isStructSame(a, b) {

    // If both subtrees are null, return 
    // true.
    if (a === null && b === null)
        return true;

    // If one of the subtrees is null,
    // return false.
    if (a === null || b === null)
        return false;

    // check left and right subtree.    
    return isStructSame(a.left, b.left) 
        && 
        isStructSame(a.right, b.right);
}

// Function to check if a tree is foldable.
function isFoldable(root) {
    if (root === null)
        return true;

    // Convert left subtree into 
    // its mirror.
    mirror(root.left);

    // Compare the left subtree 
    // and right subtree.
    let ans = isStructSame(root.left, root.right);

    // Revert the left subtree.
    mirror(root.left);

    return ans;
}

// The constructed binary tree is
//      1
//     / \
//     2   3
//     \  /
//     4 5
let root = new Node(1);
root.left = new Node(2);
root.right = new Node(3);
root.left.right = new Node(4);
root.right.left = new Node(5);

if (isFoldable(root)) {
    console.log("True");
} else {
    console.log("False");
}

Output

True

[Expected Approach - 2] By Comparing Subtree Nodes Recursively - O(n) Time and O(h) Space

The idea is to recursively check if the left and right subtree are mirror or not. For each node a (of left subtree) and b (of right subtree), recursively compare the left subtree of a with right subtree of b and compare the right subtree of a with left subtree of b. If both are mirror structures, return true. Otherwise, return false.

C++

// C++ program to check foldable binary tree
#include <bits/stdc++.h>
using namespace std;

class Node {
public:
    int data;
    Node *left, *right;
    Node (int x) {
        data = x;
        left = nullptr;
        right = nullptr;
    }
};

// function to check if two trees are 
// mirrors 
bool isFoldableRecur(Node* a, Node* b) {
    
    // If both subtrees are null, return 
    // true.
    if (a == nullptr && b == nullptr)
        return true;
        
    // If one of the subtrees is null,
    // return false.
    if (a == nullptr || b == nullptr) 
        return false;
    
    // Compare left subtree of tree 'a' with 
    // right subtree of tree 'b' and compare 
    // right subtree of tree 'a' with left 
    // subtree of tree 'b'.
    return isFoldableRecur(a->left, b->right) 
    &&
    isFoldableRecur(a->right, b->left);
}

// Function to check if a tree is foldable.
bool isFoldable(Node* root) {
    if (root == nullptr) 
        return true;
        
    return isFoldableRecur(root->left, root->right);
}

int main() {
    
    // The constructed binary tree is
    //      1
    //     / \
    //     2 3
    //     \ /
    //     4 5
    Node* root = new Node(1);
    root->left = new Node(2);
    root->right = new Node(3);
    root->left->right = new Node(4);
    root->right->left = new Node(5);

    if (isFoldable(root)) {
        cout << "True" << endl;
    } else {
        cout << "False" << endl;
    }
    return 0;
}

C

// C program to check foldable binary tree
#include <stdio.h>
#include <stdlib.h>

struct Node {
    int data;
    struct Node* left;
    struct Node* right;
};

// function to check if two trees are 
// mirrors 
int isFoldableRecur(struct Node* a, struct Node* b) {

    // If both subtrees are null, return 
    // true.
    if (a == NULL && b == NULL)
        return 1;

    // If one of the subtrees is null,
    // return false.
    if (a == NULL || b == NULL)
        return 0;

    // Compare left subtree of tree 'a' with 
    // right subtree of tree 'b' and compare 
    // right subtree of tree 'a' with left 
    // subtree of tree 'b'.
    return isFoldableRecur(a->left, b->right)
        && isFoldableRecur(a->right, b->left);
}

// Function to check if a tree is foldable.
int isFoldable(struct Node* root) {
    if (root == NULL)
        return 1;

    return isFoldableRecur(root->left, root->right);
}

struct Node* createNode(int x) {
    struct Node* newNode = 
    (struct Node*)malloc(sizeof(struct Node));
    newNode->data = x;
    newNode->left = NULL;
    newNode->right = NULL;
    return newNode;
}

int main() {

    // The constructed binary tree is
    //      1
    //     / \
    //     2 3
    //     \ /
    //     4 5
    struct Node* root = createNode(1);
    root->left = createNode(2);
    root->right = createNode(3);
    root->left->right = createNode(4);
    root->right->left = createNode(5);

    if (isFoldable(root)) {
        printf("True\n");
    } else {
        printf("False\n");
    }

    return 0;
}

Java

// Java program to check foldable binary tree
class Node {
    int data;
    Node left, right;

    Node(int x) {
        data = x;
        left = null;
        right = null;
    }
}

class GfG {

    // function to check if two trees are 
    // mirrors 
    static boolean isFoldableRecur(Node a, Node b) {

        // If both subtrees are null, return 
        // true.
        if (a == null && b == null)
            return true;

        // If one of the subtrees is null,
        // return false.
        if (a == null || b == null)
            return false;

        // Compare left subtree of tree 'a' with 
        // right subtree of tree 'b' and compare 
        // right subtree of tree 'a' with left 
        // subtree of tree 'b'.
        return isFoldableRecur(a.left, b.right) &&
                isFoldableRecur(a.right, b.left);
    }

    // Function to check if a tree is foldable.
    static boolean isFoldable(Node root) {
        if (root == null)
            return true;

        return isFoldableRecur(root.left, root.right);
    }

    public static void main(String[] args) {

        // The constructed binary tree is
        //      1
        //     / \
        //     2 3
        //     \ /
        //     4 5
        Node root = new Node(1);
        root.left = new Node(2);
        root.right = new Node(3);
        root.left.right = new Node(4);
        root.right.left = new Node(5);

        if (isFoldable(root)) {
            System.out.println("True");
        } else {
            System.out.println("False");
        }
    }
}

Python

# Python program to check foldable binary tree

class Node:
    def __init__(self, x):
        self.data = x
        self.left = None
        self.right = None

# function to check if two trees are 
# mirrors 
def isFoldableRecur(a, b):
    
    # If both subtrees are null, return 
    # true.
    if a is None and b is None:
        return True
    
    # If one of the subtrees is null,
    # return false.
    if a is None or b is None:
        return False
    
    # Compare left subtree of tree 'a' with 
    # right subtree of tree 'b' and compare 
    # right subtree of tree 'a' with left 
    # subtree of tree 'b'.
    return isFoldableRecur(a.left, b.right) and isFoldableRecur(a.right, b.left)

# Function to check if a tree is foldable.
def isFoldable(root):
    if root is None:
        return True
    
    return isFoldableRecur(root.left, root.right)

if __name__ == "__main__":

    # The constructed binary tree is
    #      1
    #     / \
    #     2 3
    #     \ /
    #     4 5
    root = Node(1)
    root.left = Node(2)
    root.right = Node(3)
    root.left.right = Node(4)
    root.right.left = Node(5)

    if isFoldable(root):
        print("True")
    else:
        print("False")

C#

// C# program to check foldable binary tree
using System;

class Node {
    public int data;
    public Node left, right;

    public Node(int x) {
        data = x;
        left = null;
        right = null;
    }
}

class GfG {

    // function to check if two trees are 
	// mirrors 
    static bool isFoldableRecur(Node a, Node b) {

        // If both subtrees are null, return 
        // true.
        if (a == null && b == null)
            return true;

        // If one of the subtrees is null,
        // return false.
        if (a == null || b == null)
            return false;

        // Compare left subtree of tree 'a' with 
        // right subtree of tree 'b' and compare 
        // right subtree of tree 'a' with left 
        // subtree of tree 'b'.
        return isFoldableRecur(a.left, b.right)
            && isFoldableRecur(a.right, b.left);
    }

    // Function to check if a tree is foldable.
    static bool isFoldable(Node root) {
        if (root == null)
            return true;

        return isFoldableRecur(root.left, root.right);
    }

    static void Main() {

        // The constructed binary tree is
        //      1
        //     / \
        //     2 3
        //     \ /
        //     4 5
        Node root = new Node(1);
        root.left = new Node(2);
        root.right = new Node(3);
        root.left.right = new Node(4);
        root.right.left = new Node(5);

        if (isFoldable(root)) {
            Console.WriteLine("True");
        } else {
            Console.WriteLine("False");
        }
    }
}

JavaScript

// JavaScript program to check foldable binary tree

class Node {
    constructor(x) {
        this.data = x;
        this.left = null;
        this.right = null;
    }
}

// function to check if two trees are 
// mirrors 
function isFoldableRecur(a, b) {

    // If both subtrees are null, return 
    // true.
    if (a === null && b === null)
        return true;

    // If one of the subtrees is null,
    // return false.
    if (a === null || b === null)
        return false;

    // Compare left subtree of tree 'a' with 
    // right subtree of tree 'b' and compare 
    // right subtree of tree 'a' with left 
    // subtree of tree 'b'.
    return isFoldableRecur(a.left, b.right)
        && isFoldableRecur(a.right, b.left);
}

// Function to check if a tree is foldable.
function isFoldable(root) {
    if (root === null)
        return true;

    return isFoldableRecur(root.left, root.right);
}

// The constructed binary tree is
//      1
//     / \
//     2   3
//     \   /
//     4   5
let root = new Node(1);
root.left = new Node(2);
root.right = new Node(3);
root.left.right = new Node(4);
root.right.left = new Node(5);

if (isFoldable(root)) {
    console.log("True");
} else {
    console.log("False");
}

Output

True

[Expected Approach - 3] Using Breadth first Search - O(n) Time and O(n) Space

The idea is to use Queue for traversing the tree and using the BFS approach. Push the left node and right node of the root into a queue. While queue is not empty, pop two nodes, a (left subtree node) and b (right subtree node). If both are null nodes, continue. If one of them is null, return false. Push the left node of a with the right node of b, and push the right node of a with the left node of b. If queue becomes empty, return true.

C++

// C++ program to check foldable binary tree
#include <bits/stdc++.h>
using namespace std;

class Node {
public:
    int data;
    Node *left, *right;
    Node (int x) {
        data = x;
        left = nullptr;
        right = nullptr;
    }
};

// Function to check if a tree is foldable.
bool isFoldable(Node* root) {
    if (root == nullptr) 
        return true;
        
    queue<Node*> q;
    q.push(root->left);
    q.push(root->right);
    
    while (!q.empty()) {
        Node *a = q.front();
        q.pop();
        Node* b = q.front();
        q.pop();
        
        // If both subtrees are null, continue.
        if (a == nullptr && b == nullptr)
            continue;
            
        // If one of the subtrees is null,
        // return false.
        if (a==nullptr || b==nullptr)
            return false;
            
        // Push left node of a and right 
        // node of b.
        q.push(a->left);
        q.push(b->right);
        
        // Push right node of b and left 
        // node of a.
        q.push(a->right);
        q.push(b->left);
    }
    
    return true;
}

int main() {
    
    // The constructed binary tree is
    //      1
    //     / \
    //     2 3
    //     \ /
    //     4 5
    Node* root = new Node(1);
    root->left = new Node(2);
    root->right = new Node(3);
    root->left->right = new Node(4);
    root->right->left = new Node(5);

    if (isFoldable(root)) {
        cout << "True" << endl;
    } else {
        cout << "False" << endl;
    }
    return 0;
}

Java

// Java program to check foldable binary tree
import java.util.LinkedList;
import java.util.Queue;

class Node {
    int data;
    Node left, right;

    Node(int x) {
        data = x;
        left = null;
        right = null;
    }
}

class GfG {
    
    // Function to check if a tree is foldable.
    static boolean isFoldable(Node root) {
        if (root == null)
            return true;

        Queue<Node> q = new LinkedList<>();
        q.add(root.left);
        q.add(root.right);

        while (!q.isEmpty()) {
            Node a = q.poll();
            Node b = q.poll();

            // If both subtrees are null, continue.
            if (a == null && b == null)
                continue;

            // If one of the subtrees is null,
            // return false.
            if (a == null || b == null)
                return false;

            // Push left node of a and right
            // node of b.
            q.add(a.left);
            q.add(b.right);

            // Push right node of a and left
            // node of b.
            q.add(a.right);
            q.add(b.left);
        }

        return true;
    }

    public static void main(String[] args) {

        // The constructed binary tree is
        //      1
        //     / \
        //     2   3
        //     \   /
        //     4   5
        Node root = new Node(1);
        root.left = new Node(2);
        root.right = new Node(3);
        root.left.right = new Node(4);
        root.right.left = new Node(5);

        if (isFoldable(root)) {
            System.out.println("True");
        } else {
            System.out.println("False");
        }
    }
}

Python

# Python program to check foldable binary tree
from collections import deque

class Node:
    def __init__(self, x):
        self.data = x
        self.left = None
        self.right = None

# Function to check if a tree is foldable.
def isFoldable(root):
    if root is None:
        return True

    q = deque([root.left, root.right])

    while q:
        a = q.popleft()
        b = q.popleft()

        # If both subtrees are null, continue.
        if a is None and b is None:
            continue

        # If one of the subtrees is null,
        # return false.
        if a is None or b is None:
            return False

        # Push left node of a and right
        # node of b.
        q.append(a.left)
        q.append(b.right)

        # Push right node of a and left
        # node of b.
        q.append(a.right)
        q.append(b.left)

    return True

if __name__ == "__main__":

    # The constructed binary tree is
    #      1
    #     / \
    #     2   3
    #     \   /
    #     4   5
    root = Node(1)
    root.left = Node(2)
    root.right = Node(3)
    root.left.right = Node(4)
    root.right.left = Node(5)

    if isFoldable(root):
        print("True")
    else:
        print("False")

C#

// C# program to check foldable binary tree
using System;
using System.Collections.Generic;

class Node {
    public int data;
    public Node left, right;

    public Node(int x) {
        data = x;
        left = null;
        right = null;
    }
}

class GfG {
    
    // Function to check if a tree is foldable.
    static bool isFoldable(Node root) {
        if (root == null)
            return true;

        Queue<Node> q = new Queue<Node>();
        q.Enqueue(root.left);
        q.Enqueue(root.right);

        while (q.Count > 0) {
            Node a = q.Dequeue();
            Node b = q.Dequeue();

            // If both subtrees are null, continue.
            if (a == null && b == null)
                continue;

            // If one of the subtrees is null,
            // return false.
            if (a == null || b == null)
                return false;

            // Push left node of a and right
            // node of b.
            q.Enqueue(a.left);
            q.Enqueue(b.right);

            // Push right node of a and left
            // node of b.
            q.Enqueue(a.right);
            q.Enqueue(b.left);
        }

        return true;
    }

    static void Main(string[] args) {

        // The constructed binary tree is
        //      1
        //     / \
        //     2   3
        //     \   /
        //     4   5
        Node root = new Node(1);
        root.left = new Node(2);
        root.right = new Node(3);
        root.left.right = new Node(4);
        root.right.left = new Node(5);

        if (isFoldable(root)) {
            Console.WriteLine("True");
        } else {
            Console.WriteLine("False");
        }
    }
}

JavaScript

// JavaScript program to check foldable 
// binary tree

class Node {
    constructor(x) {
        this.data = x;
        this.left = null;
        this.right = null;
    }
}

// Function to check if a tree is foldable.
function isFoldable(root) {
    if (root === null)
        return true;

    let q = [];
    q.push(root.left);
    q.push(root.right);

    while (q.length) {
        let a = q.shift();
        let b = q.shift();

        // If both subtrees are null, continue.
        if (a === null && b === null)
            continue;

        // If one of the subtrees is null,
        // return false.
        if (a === null || b === null)
            return false;

        // Push left node of a and right
        // node of b.
        q.push(a.left);
        q.push(b.right);

        // Push right node of a and left
        // node of b.
        q.push(a.right);
        q.push(b.left);
    }

    return true;
}

// The constructed binary tree is
//      1
//     / \
//     2   3
//     \   /
//     4   5
let root = new Node(1);
root.left = new Node(2);
root.right = new Node(3);
root.left.right = new Node(4);
root.right.left = new Node(5);

if (isFoldable(root)) {
    console.log("True");
} else {
    console.log("False");
}

Output

True

Symmetric Tree (Mirror Image of itself)

kartik

Improve

Article Tags :

Practice Tags :

Similar Reads

Binary Tree Data Structure

A Binary Tree Data Structure is a hierarchical data structure in which each node has at most two children, referred to as the left child and the right child. It is commonly used in computer science for efficient storage and retrieval of data, with various operations such as insertion, deletion, and

Introduction to Binary Tree

Binary Tree is a non-linear and hierarchical data structure where each node has at most two children referred to as the left child and the right child. The topmost node in a binary tree is called the root, and the bottom-most nodes are called leaves. Introduction to Binary TreeRepresentation of Bina

Properties of Binary Tree

This post explores the fundamental properties of a binary tree, covering its structure, characteristics, and key relationships between nodes, edges, height, and levelsBinary tree representationNote: Height of root node is considered as 0. Properties of Binary Trees1. Maximum Nodes at Level 'l'A bina

Applications, Advantages and Disadvantages of Binary Tree

A binary tree is a tree that has at most two children for any of its nodes. There are several types of binary trees. To learn more about them please refer to the article on "Types of binary tree" Applications:General ApplicationsDOM in HTML: Binary trees help manage the hierarchical structure of web

Binary Tree (Array implementation)

Given an array that represents a tree in such a way that array indexes are values in tree nodes and array values give the parent node of that particular index (or node). The value of the root node index would always be -1 as there is no parent for root. Construct the standard linked representation o

Maximum Depth of Binary Tree

Given a binary tree, the task is to find the maximum depth of the tree. The maximum depth or height of the tree is the number of edges in the tree from the root to the deepest node.Examples:Input: Output: 2Explanation: The longest path from the root (node 12) goes through node 8 to node 5, which has

Insertion in a Binary Tree in level order

Given a binary tree and a key, the task is to insert the key into the binary tree at the first position available in level order manner.Examples:Input: key = 12 Output: Explanation: Node with value 12 is inserted into the binary tree at the first position available in level order manner.Approach:The

Deletion in a Binary Tree

Given a binary tree, the task is to delete a given node from it by making sure that the tree shrinks from the bottom (i.e. the deleted node is replaced by the bottom-most and rightmost node). This is different from BST deletion. Here we do not have any order among elements, so we replace them with t

Enumeration of Binary Trees

A Binary Tree is labeled if every node is assigned a label and a Binary Tree is unlabelled if nodes are not assigned any label. Below two are considered same unlabelled trees o o / \ / \ o o o o Below two are considered different labelled trees A C / \ / \ B C A B How many different Unlabelled Binar