Skip to content
geeksforgeeks
  • Courses
    • DSA to Development
    • Get IBM Certification
    • Newly Launched!
      • Master Django Framework
      • Become AWS Certified
    • For Working Professionals
      • Interview 101: DSA & System Design
      • Data Science Training Program
      • JAVA Backend Development (Live)
      • DevOps Engineering (LIVE)
      • Data Structures & Algorithms in Python
    • For Students
      • Placement Preparation Course
      • Data Science (Live)
      • Data Structure & Algorithm-Self Paced (C++/JAVA)
      • Master Competitive Programming (Live)
      • Full Stack Development with React & Node JS (Live)
    • Full Stack Development
    • Data Science Program
    • All Courses
  • Tutorials
    • Data Structures & Algorithms
    • ML & Data Science
    • Interview Corner
    • Programming Languages
    • Web Development
    • CS Subjects
    • DevOps And Linux
    • School Learning
  • Practice
    • Build your AI Agent
    • GfG 160
    • Problem of the Day
    • Practice Coding Problems
    • GfG SDE Sheet
  • Contests
    • Accenture Hackathon (Ending Soon!)
    • GfG Weekly [Rated Contest]
    • Job-A-Thon Hiring Challenge
    • All Contests and Events
  • DSA
  • Interview Problems on Tree
  • Practice Tree
  • MCQs on Tree
  • Tutorial on Tree
  • Types of Trees
  • Basic operations
  • Tree Traversal
  • Binary Tree
  • Complete Binary Tree
  • Ternary Tree
  • Binary Search Tree
  • Red-Black Tree
  • AVL Tree
  • Full Binary Tree
  • B-Tree
  • Advantages & Disadvantages
Open In App
Next Article:
Check mirror in n-ary tree
Next article icon

Invert Binary Tree – Change to Mirror Tree

Last Updated : 06 Feb, 2025
Comments
Improve
Suggest changes
Like Article
Like
Report
Try it on GfG Practice
redirect icon

Given a binary tree, the task is to convert the binary tree to its Mirror tree. Mirror of a Binary Tree T is another Binary Tree M(T) with left and right children of all non-leaf nodes interchanged.

Example 1:

invert-binary-tree-1

Explanation: In the inverted tree, every non-leaf node has its left and right child interchanged.

Example 2:

invert-binary-tree-2

Explanation: In the inverted tree, every non-leaf node has its left and right child interchanged.

Table of Content

  • Recursive Approach – O(n) Time and O(h) Space
  • Iterative Approach – O(n) Time and O(n) Space

Recursive Approach – O(n) Time and O(h) Space

The idea is to use recursion to traverse the tree in Post Order (left, right, root) and while traversing each node, swap the left and right subtrees.

C++ 
//Driver Code Starts{ // C++ Program Invert a Binary Tree using Recursive Postorder  #include <iostream> #include <queue> using namespace std;  class Node { public:     int data;     Node *left, *right;     Node(int x) {         data = x;         left = nullptr;         right = nullptr;     } }; //Driver Code Ends }   // function to return the root of inverted tree void mirror(Node* root) {     if (root == nullptr)         return ;          // Invert the left and right subtree     mirror(root->left);     mirror(root->right);        // Swap the left and right subtree 	swap(root->left, root->right); }  // Print tree as level order void levelOrder(Node *root) {     if (root == nullptr) {       	cout << "N ";       	return ;     }      queue<Node*> qq;     qq.push(root);      while (!qq.empty()) {         Node *curr = qq.front();         qq.pop();          if (curr == nullptr) {             cout << "N ";             continue;         }         cout << (curr->data) <<  " ";         qq.push(curr->left);         qq.push(curr->right);     } }   //Driver Code Starts{ int main() {      // Input Tree:     //       1     //      / \     //     2   3     //    / \     //   4   5     Node* root = new Node(1);     root->left = new Node(2);     root->right = new Node(3);     root->left->left = new Node(4);     root->left->right = new Node(5);  	mirror(root);        // Mirror Tree:     //       1     //      / \     //     3   2     //        / \     //       5   4     levelOrder(root);      return 0; }  //Driver Code Ends }
C 
//Driver Code Starts{ // C Program Invert a Binary Tree using Recursive Postorder  #include <stdio.h> #include <stdlib.h> #include <stdbool.h>  typedef struct Node {     int data;     struct Node* left;     struct Node* right; } Node;  // Function to create a new node Node* newNode(int x) {     Node* node = (Node*)malloc(sizeof(Node));     node->data = x;     node->left = NULL;     node->right = NULL;     return node; } //Driver Code Ends }   // Function to return the root of inverted tree void mirror(Node* root) {     if (root == NULL)         return ;      // Invert the left and right subtree 	mirror(root->left); 	mirror(root->right);      // Swap the left and right subtree     struct Node* temp = root->left;   	root->left = root->right;   	root->right = temp; }  // Print tree as level order void levelOrder(Node* root) {     if (root == NULL) {         printf("N ");         return;     }      Node* queue[100];     int front = 0, rear = 0;      queue[rear++] = root;      while (front < rear) {         Node* curr = queue[front++];          if (curr == NULL) {             printf("N ");             continue;         }          printf("%d ", curr->data);         queue[rear++] = curr->left;         queue[rear++] = curr->right;     } }   //Driver Code Starts{ int main() {     // Input Tree:     //       1     //      / \     //     2   3     //    / \     //   4   5     Node* root = newNode(1);     root->left = newNode(2);     root->right = newNode(3);     root->left->left = newNode(4);     root->left->right = newNode(5);  	mirror(root);      // Mirror Tree:     //       1     //      / \     //     3   2     //        / \     //       5   4     levelOrder(root);      return 0; }  //Driver Code Ends }
Java 
//Driver Code Starts{ // Java Program Invert a Binary Tree using Recursive Postorder  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 { //Driver Code Ends }       // Function to return the root of inverted tree     static void mirror(Node root) {         if (root == null)             return ;          // Invert the left and right subtree 		mirror(root.left); 		mirror(root.right);          // Swap the left and right subtree         Node temp = root.left;         root.left = root.right;         root.right = temp;     }      // Print tree as level order     static void levelOrder(Node root) {         if (root == null) {             System.out.print("N ");             return;         }          Queue<Node> queue = new LinkedList<>();         queue.add(root);          while (!queue.isEmpty()) {             Node curr = queue.poll();              if (curr == null) {                 System.out.print("N ");                 continue;             }             System.out.print(curr.data + " ");             queue.add(curr.left);             queue.add(curr.right);         }     }   //Driver Code Starts{     public static void main(String[] args) {         // Input Tree:         //       1         //      / \         //     2   3         //    / \         //   4   5         Node root = new Node(1);         root.left = new Node(2);         root.right = new Node(3);         root.left.left = new Node(4);         root.left.right = new Node(5);          mirror(root);          // Mirror Tree:         //       1         //      / \         //     3   2         //        / \         //       5   4         levelOrder(root);     } }   //Driver Code Ends }
Python 
#Driver Code Starts{ # Python Program Invert a Binary Tree using Recursive Postorder  from collections import deque  class Node:     def __init__(self, x):         self.data = x         self.left = None         self.right = None #Driver Code Ends }   # Function to return the root of inverted tree def mirror(root):     if root is None:         return          # Invert the left and right subtree     mirror(root.left)     mirror(root.right)      # Swap the left and right subtree     temp = root.left     root.left = root.right     root.right = temp  # Print tree as level order def levelOrder(root):     if root is None:         print("N ", end="")         return      queue = deque([root])      while queue:         curr = queue.popleft()          if curr is None:             print("N ", end="")             continue          print(curr.data, end=" ")         queue.append(curr.left)         queue.append(curr.right)   #Driver Code Starts{ if __name__ == "__main__":     # Input Tree:     #       1     #      / \     #     2   3     #    / \     #   4   5     root = Node(1)     root.left = Node(2)     root.right = Node(3)     root.left.left = Node(4)     root.left.right = Node(5)      mirror(root)      # Mirror Tree:     #       1     #      / \     #     3   2     #        / \     #       5   4     levelOrder(root)   #Driver Code Ends }
C# 
//Driver Code Starts{ // C# Program Invert a Binary Tree using Recursive Postorder  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 { //Driver Code Ends }       // Function to return the root of inverted tree     static void mirror(Node root) {         if (root == null)             return ;          // Invert the left and right subtree 		mirror(root.left); 		mirror(root.right);          // Swap the left and right subtree         Node temp = root.left;       	root.left = root.right;         root.right = temp;     }      // Print tree as level order     static void levelOrder(Node root) {         if (root == null) {             Console.Write("N ");             return;         }          Queue<Node> queue = new Queue<Node>();         queue.Enqueue(root);          while (queue.Count > 0) {             Node curr = queue.Dequeue();              if (curr == null) {                 Console.Write("N ");                 continue;             }             Console.Write(curr.data + " ");             queue.Enqueue(curr.left);             queue.Enqueue(curr.right);         }     }   //Driver Code Starts{     static void Main(string[] args) {         // Input Tree:         //       1         //      / \         //     2   3         //    / \         //   4   5         Node root = new Node(1);         root.left = new Node(2);         root.right = new Node(3);         root.left.left = new Node(4);         root.left.right = new Node(5);          mirror(root);          // Mirror Tree:         //       1         //      / \         //     3   2         //        / \         //       5   4         levelOrder(root);     } }   //Driver Code Ends }
JavaScript 
//Driver Code Starts{ // JavaScript Program Invert a Binary Tree using Recursive Postorder  class Node {     constructor(x) {         this.data = x;         this.left = null;         this.right = null;     } } //Driver Code Ends }   // Function to return the root of inverted tree function mirror(root) {     if (root === null)         return;      // Invert the left and right subtree 	mirror(root.left); 	mirror(root.right);      // Swap the left and right subtree     let temp = root.left;     root.left = root.right;     root.right = temp; }  // Print tree as level order function levelOrder(root) {     if (root === null) {         process.stdout.write("N ");         return;     }      let queue = [];     queue.push(root);      while (queue.length > 0) {         let curr = queue.shift();          if (curr === null) {             process.stdout.write("N ");             continue;         }         process.stdout.write(curr.data + " ");         queue.push(curr.left);         queue.push(curr.right);     } }   //Driver Code Starts{ // Driver Code  // Input Tree: //       1 //      / \ //     2   3 //    / \ //   4   5 let root = new Node(1); root.left = new Node(2); root.right = new Node(3); root.left.left = new Node(4); root.left.right = new Node(5);  mirror(root);  // Mirror Tree: //       1 //      / \ //     3   2 //        / \ //       5   4 levelOrder(root);  //Driver Code Ends }

Output
1 3 2 N N 5 4 N N N N

Time Complexity: O(n), Visiting all the nodes of the tree of size n.
Auxiliary Space: O(h), where h is the height of binary tree.

Iterative Approach – O(n) Time and O(n) Space

The idea is to perform Level Order Traversal using a queue to store the nodes whose left and right pointers need to be swapped. Start with the root node. Till queue is not empty, remove the node from the front, swap its left and right child and push both of the children into the queue. After iterating over all the nodes, we will get the mirror tree.

C++ 
//Driver Code Starts{ // C++ Program Invert a Binary Tree using Iterative Level Order  #include <iostream> #include <queue>  using namespace std;  struct Node {     int data;     Node *left, *right;     Node(int x) {         data = x;         left = nullptr;         right = nullptr;     } }; //Driver Code Ends }   // function to return the root of inverted tree void mirror(Node* root) {     if (root == nullptr)         return ;          queue<Node*> q;     q.push(root);          // Traverse the tree, level by level     while(!q.empty()) {         Node* curr = q.front();         q.pop();                // Swap the left and right subtree         swap(curr->left, curr->right);                // Push the left and right node to the queue         if(curr->left != nullptr)           q.push(curr->left);         if(curr->right != nullptr)           q.push(curr->right);     } }  // Print tree as level order void levelOrder(Node *root) {     if (root == nullptr) {       	cout << "N ";       	return ;     }      queue<Node*> qq;     qq.push(root);      while (!qq.empty()) {         Node *curr = qq.front();         qq.pop();          if (curr == nullptr) {             cout << "N ";             continue;         }         cout << (curr->data) <<  " ";         qq.push(curr->left);         qq.push(curr->right);     } }   //Driver Code Starts{ int main() {      // Input Tree:     //       1     //      / \     //     2   3     //    / \     //   4   5     Node* root = new Node(1);     root->left = new Node(2);     root->right = new Node(3);     root->left->left = new Node(4);     root->left->right = new Node(5);      mirror(root);        // Mirror Tree:     //       1     //      / \     //     3   2     //        / \     //       5   4     levelOrder(root);      return 0; }  //Driver Code Ends }
C 
//Driver Code Starts{ // C Program Invert a Binary Tree using Iterative Level Order  #include <stdio.h> #include <stdlib.h>  // Node structure typedef struct Node {     int data;     struct Node* left;     struct Node* right; } Node;  // Function to create a new node Node* newNode(int x) {     Node* node = (Node*)malloc(sizeof(Node));     node->data = x;     node->left = NULL;     node->right = NULL;     return node; } //Driver Code Ends }   // Function to return the root of inverted tree void mirror(Node* root) {     if (root == NULL)         return;      Node* queue[100];     int front = 0, rear = 0;      queue[rear++] = root;      // Traverse the tree, level by level     while (front < rear) {         Node* curr = queue[front++];                // Swap the left and right subtree         Node* temp = curr->left;         curr->left = curr->right;         curr->right = temp;          // Push the left and right node to the queue         if (curr->left != NULL)             queue[rear++] = curr->left;         if (curr->right != NULL)             queue[rear++] = curr->right;     } }  // Print tree as level order void levelOrder(Node* root) {     if (root == NULL) {         printf("N ");         return;     }      Node* queue[100];     int front = 0, rear = 0;      queue[rear++] = root;      while (front < rear) {         Node* curr = queue[front++];          if (curr == NULL) {             printf("N ");             continue;         }         printf("%d ", curr->data);         queue[rear++] = curr->left;         queue[rear++] = curr->right;     } }   //Driver Code Starts{ int main() {     // Input Tree:     //       1     //      / \     //     2   3     //    / \     //   4   5     Node* root = newNode(1);     root->left = newNode(2);     root->right = newNode(3);     root->left->left = newNode(4);     root->left->right = newNode(5);      mirror(root);        // Mirror Tree:     //       1     //      / \     //     3   2     //        / \     //       5   4     levelOrder(root);      return 0; }  //Driver Code Ends }
Java 
//Driver Code Starts{ // Java Program Invert a Binary Tree using Iterative Level Order  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 { //Driver Code Ends }       // Function to return the root of inverted tree     static void mirror(Node root) {         if (root == null)             return;          Queue<Node> queue = new LinkedList<>();         queue.add(root);          // Traverse the tree, level by level         while (!queue.isEmpty()) {             Node curr = queue.poll();              // Swap the left and right subtree             Node temp = curr.left;             curr.left = curr.right;             curr.right = temp;              // Push the left and right node to the queue             if (curr.left != null)                 queue.add(curr.left);             if (curr.right != null)                 queue.add(curr.right);         }     }      // Print tree as level order     static void levelOrder(Node root) {         if (root == null) {             System.out.print("N ");             return;         }          Queue<Node> queue = new LinkedList<>();         queue.add(root);          while (!queue.isEmpty()) {             Node curr = queue.poll();              if (curr == null) {                 System.out.print("N ");                 continue;             }             System.out.print(curr.data + " ");             queue.add(curr.left);             queue.add(curr.right);         }     }   //Driver Code Starts{     public static void main(String[] args) {         // Input Tree:         //       1         //      / \         //     2   3         //    / \         //   4   5         Node root = new Node(1);         root.left = new Node(2);         root.right = new Node(3);         root.left.left = new Node(4);         root.left.right = new Node(5);          mirror(root);          // Mirror Tree:         //       1         //      / \         //     3   2         //        / \         //       5   4         levelOrder(root);     } }  //Driver Code Ends }
Python 
#Driver Code Starts{ # Python Program Invert a Binary Tree using Iterative Level Order  from collections import deque  class Node:     def __init__(self, x):         self.data = x         self.left = None         self.right = None #Driver Code Ends }   # Function to return the root of inverted tree def mirror(root):     if root is None:         return      queue = deque([root])      # Traverse the tree, level by level     while queue:         curr = queue.popleft()          # Swap the left and right subtree         curr.left, curr.right = curr.right, curr.left          # Push the left and right node to the queue         if curr.left:             queue.append(curr.left)         if curr.right:             queue.append(curr.right)  # Print tree as level order def levelOrder(root):     if root is None:         print("N ", end="")         return      queue = deque([root])      while queue:         curr = queue.popleft()          if curr is None:             print("N ", end="")             continue          print(curr.data, end=" ")         queue.append(curr.left)         queue.append(curr.right)   #Driver Code Starts{ if __name__ == "__main__":     # Input Tree:     #       1     #      / \     #     2   3     #    / \     #   4   5     root = Node(1)     root.left = Node(2)     root.right = Node(3)     root.left.left = Node(4)     root.left.right = Node(5)      mirror(root)      # Mirror Tree:     #       1     #      / \     #     3   2     #        / \     #       5   4     levelOrder(root)  #Driver Code Ends }
C# 
//Driver Code Starts{ // C# Program Invert a Binary Tree using Iterative Level Order  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 { //Driver Code Ends }         // Function to return the root of inverted tree     static void mirror(Node root) {         if (root == null)             return;          Queue<Node> queue = new Queue<Node>();         queue.Enqueue(root);          // Traverse the tree, level by level         while (queue.Count > 0) {             Node curr = queue.Dequeue();              // Swap the left and right subtree             Node temp = curr.left;             curr.left = curr.right;             curr.right = temp;              // Push the left and right node to the queue             if (curr.left != null)                 queue.Enqueue(curr.left);             if (curr.right != null)                 queue.Enqueue(curr.right);         }     }      // Print tree as level order     static void levelOrder(Node root) {         if (root == null) {             Console.Write("N ");             return;         }          Queue<Node> queue = new Queue<Node>();         queue.Enqueue(root);          while (queue.Count > 0) {             Node curr = queue.Dequeue();              if (curr == null) {                 Console.Write("N ");                 continue;             }             Console.Write(curr.data + " ");             queue.Enqueue(curr.left);             queue.Enqueue(curr.right);         }     }   //Driver Code Starts{     static void Main(string[] args) {         // Input Tree:         //       1         //      / \         //     2   3         //    / \         //   4   5         Node root = new Node(1);         root.left = new Node(2);         root.right = new Node(3);         root.left.left = new Node(4);         root.left.right = new Node(5);          mirror(root);          // Mirror Tree:         //       1         //      / \         //     3   2         //        / \         //       5   4         levelOrder(root);     } }  //Driver Code Ends }
JavaScript 
//Driver Code Starts{ // JavaScript Program Invert a Binary Tree using Iterative Level Order  class Node {     constructor(x) {         this.data = x;         this.left = null;         this.right = null;     } } //Driver Code Ends }   // Function to return the root of inverted tree function mirror(root) {     if (root === null)         return;      let queue = [];     queue.push(root);      // Traverse the tree, level by level     while (queue.length > 0) {         let curr = queue.shift();          // Swap the left and right subtree         [curr.left, curr.right] = [curr.right, curr.left];          // Push the left and right node to the queue         if (curr.left)             queue.push(curr.left);         if (curr.right)             queue.push(curr.right);     } }  // Print tree as level order function levelOrder(root) {     if (root === null) {         process.stdout.write("N ");         return;     }      let queue = [];     queue.push(root);      while (queue.length > 0) {         let curr = queue.shift();          if (curr === null) {             process.stdout.write("N ");             continue;         }          process.stdout.write(curr.data + " ");         queue.push(curr.left);         queue.push(curr.right);     } }   //Driver Code Starts{ // Driver Code  // Input Tree: //       1 //      / \ //     2   3 //    / \ //   4   5 let root = new Node(1); root.left = new Node(2); root.right = new Node(3); root.left.left = new Node(4); root.left.right = new Node(5);  mirror(root);  // Mirror Tree: //       1 //      / \ //     3   2 //        / \ //       5   4 levelOrder(root);  //Driver Code Ends }

Output
1 3 2 N N 5 4 N N N N

Time Complexity: O(n), fro traversing over the tree of size n.
Auxiliary Space: O(n), used by queue to store the nodes of the tree.



Next Article
Check mirror in n-ary tree
author
kartik
Improve
Article Tags :
  • DSA
  • Tree
  • Accolite
  • Adobe
  • Amazon
  • Amazon-Question
  • Belzabar
  • Belzabar-Question
  • Convert to Mirror
  • cpp-queue
  • eBay
  • eBay-Question
  • Get the Mirror
  • Microsoft
  • Mirror Tree
  • Morgan Stanley
  • Myntra
  • Myntra-Question
  • Ola Cabs
  • OLA-Question
  • Paytm
  • Paytm-Question
  • Prop-Tiger-Question
  • Samsung
  • SAP Labs
  • Snapdeal
  • Snapdeal-Question
  • tree-traversal
  • Trees
  • VMWare
  • VMWare-Question
Practice Tags :
  • Accolite
  • Adobe
  • Amazon
  • Belzabar
  • eBay
  • Microsoft
  • Morgan Stanley
  • Myntra
  • Ola Cabs
  • Paytm
  • Samsung
  • SAP Labs
  • Snapdeal
  • VMWare
  • Tree

Similar Reads

  • Convert given binary tree to a XOR tree
    Given a Binary Tree where each node has a value of either 0 or 1, the task is to convert the given Binary tree to an XOR tree i.e a tree such that each node value is the logical XOR between its children. Note: Leaf nodes and nodes with one child are not considered as they don't have both children. E
    8 min read
  • Check mirror in n-ary tree
    Given two n-ary trees, determine whether they are mirror images of each other. Each tree is described by e edges, where e denotes the number of edges in both trees. Two arrays A[]and B[] are provided, where each array contains 2*e space-separated values representing the edges of both trees. Each edg
    11 min read
  • Binary Tree to Binary Search Tree Conversion
    Given a Binary Tree, the task is to convert it to a Binary Search Tree. The conversion must be done in such a way that keeps the original structure of the Binary Tree. Examples Input: Output: Explanation: The above Binary tree is converted to Binary Search tree by keeping the original structure of B
    7 min read
  • Find mirror of a given node in Binary tree
    Given a Binary tree, the problem is to find the mirror of a given node. The mirror of a node is a node which exists at the mirror position of the node in opposite subtree at the root. Examples: In above tree- Node 2 and 3 are mirror nodes Node 4 and 6 are mirror nodes. Recommended PracticeMirror of
    15+ min read
  • Check if two binary trees are mirror | Set 3
    Given two arrays, A[] and B[] consisting of M pairs, representing the edges of the two binary trees of N distinct nodes according to the level order traversal, the task is to check if trees are the mirror images of each other. Examples: Input: N = 6, M = 5, A[][2] = {{1, 5}, {1, 4}, {5, 7}, {5, 8},
    10 min read
  • Introduction to Degenerate Binary Tree
    Every non-leaf node has just one child in a binary tree known as a Degenerate Binary tree. The tree effectively transforms into a linked list as a result, with each node linking to its single child. When a straightforward and effective data structure is required, degenerate binary trees, a special c
    8 min read
  • Convert a given tree to its Sum Tree
    Given a Binary Tree where each node has positive and negative values. Convert this to a tree where each node contains the sum of the left and right sub trees in the original tree. The values of leaf nodes are changed to 0. For example, the following tree 10 / \ -2 6 / \ / \ 8 -4 7 5 should be change
    15+ min read
  • Check if two trees are Mirror | Set 2
    Given two Binary Trees, returns true if two trees are mirror of each other, else false. Mirror Tree : Previously discussed approach is here. Approach: Find the inorder traversal of both the Binary Trees, and check whether one traversal is reverse of another or not. If they are reverse of each other
    7 min read
  • Check if two trees are Mirror
    Given two Binary Trees, the task is to check if two trees are mirror of each other or not. For two trees ‘a’ and ‘b’ to be mirror images, the following three conditions must be true: Their root node’s key must be sameLeft subtree of root of ‘a’ and right subtree root of ‘b’ are mirror.Right subtree
    9 min read
  • Duplicate subtree in Binary Tree | SET 2
    Given a binary tree, the task is to check whether the binary tree contains a duplicate sub-tree of size two or more. Input: A / \ B C / \ \ D E B / \ D E Output: Yes B / \ D E is the duplicate sub-tree. Input: A / \ B C / \ D E Output: No Approach: A DFS based approach has been discussed here. A que
    8 min read
geeksforgeeks-footer-logo
Corporate & Communications Address:
A-143, 7th Floor, Sovereign Corporate Tower, Sector- 136, Noida, Uttar Pradesh (201305)
Registered Address:
K 061, Tower K, Gulshan Vivante Apartment, Sector 137, Noida, Gautam Buddh Nagar, Uttar Pradesh, 201305
GFG App on Play Store GFG App on App Store
Advertise with us
  • Company
  • About Us
  • Legal
  • Privacy Policy
  • In Media
  • Contact Us
  • Advertise with us
  • GFG Corporate Solution
  • Placement Training Program
  • Languages
  • Python
  • Java
  • C++
  • PHP
  • GoLang
  • SQL
  • R Language
  • Android Tutorial
  • Tutorials Archive
  • DSA
  • Data Structures
  • Algorithms
  • DSA for Beginners
  • Basic DSA Problems
  • DSA Roadmap
  • Top 100 DSA Interview Problems
  • DSA Roadmap by Sandeep Jain
  • All Cheat Sheets
  • Data Science & ML
  • Data Science With Python
  • Data Science For Beginner
  • Machine Learning
  • ML Maths
  • Data Visualisation
  • Pandas
  • NumPy
  • NLP
  • Deep Learning
  • Web Technologies
  • HTML
  • CSS
  • JavaScript
  • TypeScript
  • ReactJS
  • NextJS
  • Bootstrap
  • Web Design
  • Python Tutorial
  • Python Programming Examples
  • Python Projects
  • Python Tkinter
  • Python Web Scraping
  • OpenCV Tutorial
  • Python Interview Question
  • Django
  • Computer Science
  • Operating Systems
  • Computer Network
  • Database Management System
  • Software Engineering
  • Digital Logic Design
  • Engineering Maths
  • Software Development
  • Software Testing
  • DevOps
  • Git
  • Linux
  • AWS
  • Docker
  • Kubernetes
  • Azure
  • GCP
  • DevOps Roadmap
  • System Design
  • High Level Design
  • Low Level Design
  • UML Diagrams
  • Interview Guide
  • Design Patterns
  • OOAD
  • System Design Bootcamp
  • Interview Questions
  • Inteview Preparation
  • Competitive Programming
  • Top DS or Algo for CP
  • Company-Wise Recruitment Process
  • Company-Wise Preparation
  • Aptitude Preparation
  • Puzzles
  • School Subjects
  • Mathematics
  • Physics
  • Chemistry
  • Biology
  • Social Science
  • English Grammar
  • Commerce
  • World GK
  • GeeksforGeeks Videos
  • DSA
  • Python
  • Java
  • C++
  • Web Development
  • Data Science
  • CS Subjects
@GeeksforGeeks, Sanchhaya Education Private Limited, All rights reserved
We use cookies to ensure you have the best browsing experience on our website. By using our site, you acknowledge that you have read and understood our Cookie Policy & Privacy Policy
Lightbox
Improvement
Suggest Changes
Help us improve. Share your suggestions to enhance the article. Contribute your expertise and make a difference in the GeeksforGeeks portal.
geeksforgeeks-suggest-icon
Create Improvement
Enhance the article with your expertise. Contribute to the GeeksforGeeks community and help create better learning resources for all.
geeksforgeeks-improvement-icon
Suggest Changes
min 4 words, max Words Limit:1000

Thank You!

Your suggestions are valuable to us.

What kind of Experience do you want to share?

Interview Experiences
Admission Experiences
Career Journeys
Work Experiences
Campus Experiences
Competitive Exam Experiences