Skip to content

Subtree with given sum in a Binary Tree

Program to Determine if given Two Trees are Identical or not

Last Updated : 24 Sep, 2024

Try it on GfG Practice

Given two binary trees, the task is to find if both of them are identical or not. Two trees are identical when they have the same data and the arrangement of data is also the same.

Examples:

Input:

Output: Yes
Explanation: Trees are identical.

Input:

Output: No
Explanation: Trees are not identical.

Table of Content

[Expected Approach – 1] Using DFS – O(n) Time and O(n) Space

The idea is to compare the root nodes’ data and recursively verify that their left and right subtrees are identical. Both trees must have the same structure and data at each corresponding node.

Follow the given steps to solve the problem:

If both trees are empty then return 1 (Base case)
Else, If both trees are non-empty
- Check data of the root nodes (r1->data == r2->data)
- Check left subtrees recursively
- Check right subtrees recursively
- If the above three statements are true then return 1
Else return 0 (one is empty and the other is not)

Below is the implementation of the above approach:

C++

// C++ program to see if two trees are identical // using DFS #include <bits/stdc++.h> using namespace std;  struct Node {     int data;     Node *left, *right;        Node(int val) {         data = val;         left = right = nullptr;     } };  // Function to check if two trees are identical bool isIdentical(Node* r1, Node* r2) {      // If both trees are empty, they are identical     if (r1 == nullptr && r2 == nullptr)         return true;      // If only one tree is empty, they are not identical     if (r1 == nullptr || r2 == nullptr)         return false;      // Check if the root data is the same and     // recursively check for the left and right subtrees     return (r1->data == r2->data) &&            isIdentical(r1->left, r2->left) &&            isIdentical(r1->right, r2->right); }  int main() {      // Representation of input binary tree 1     //        1     //       / \     //      2   3     //     /     //    4     Node* r1 = new Node(1);         r1->left = new Node(2);        r1->right = new Node(3);      r1->left->left = new Node(4);       // Representation of input binary tree 2     //        1     //       / \     //      2   3     //     /     //    4     Node* r2 = new Node(1);         r2->left = new Node(2);        r2->right = new Node(3);       r2->left->left = new Node(4);      if (isIdentical(r1, r2))         cout << "Yes\n";     else         cout << "No\n";      return 0; }

C

// C program to see if two trees are identical // using DFS #include <stdio.h> #include <stdbool.h> #include <stdlib.h>  struct Node {     int data;     struct Node *left, *right; };  // Function to check if two trees are identical bool isIdentical(struct Node* r1, struct Node* r2) {      // If both trees are empty, they are identical     if (r1 == NULL && r2 == NULL)         return true;      // If only one tree is empty, they are not identical     if (r1 == NULL || r2 == NULL)         return false;      // Check if the root data is the same and     // recursively check for the left and right subtrees     return (r1->data == r2->data) &&            isIdentical(r1->left, r2->left) &&            isIdentical(r1->right, r2->right); }  struct Node* createNode(int val) {     struct Node *newNode        = (struct Node*)malloc(sizeof(struct Node));     newNode->data = val;     newNode->left = newNode->right = NULL;     return newNode; }  int main() {      // Representation of input binary tree 1     //        1     //       / \     //      2   3     //     /     //    4     struct Node *r1 = createNode(1);     r1->left = createNode(2);     r1->right = createNode(3);     r1->left->left = createNode(4);      // Representation of input binary tree 2     //        1     //       / \     //      2   3     //     /     //    4     struct Node *r2 = createNode(1);     r2->left = createNode(2);     r2->right = createNode(3);     r2->left->left = createNode(4);      if (isIdentical(r1, r2))         printf("Yes\n");     else         printf("No\n");      return 0; }

Java

// Java program to see if two trees are identical // using DFS class Node {     int data;     Node left, right;      Node(int val) {         data = val;         left = right = null;     } }  class GfG {      // Function to check if two trees are identical     static boolean isIdentical(Node r1, Node r2) {          // If both trees are empty, they are identical         if (r1 == null && r2 == null)             return true;          // If only one tree is empty, they are not identical         if (r1 == null || r2 == null)             return false;          // Check if the root data is the same and         // recursively check for the left and right subtrees         return (r1.data == r2.data) &&                isIdentical(r1.left, r2.left) &&                isIdentical(r1.right, r2.right);     }      public static void main(String[] args) {          // Representation of input binary tree 1         //        1         //       / \         //      2   3         //     /         //    4         Node r1 = new Node(1);         r1.left = new Node(2);         r1.right = new Node(3);         r1.left.left = new Node(4);          // Representation of input binary tree 2         //        1         //       / \         //      2   3         //     /         //    4         Node r2 = new Node(1);         r2.left = new Node(2);         r2.right = new Node(3);         r2.left.left = new Node(4);          if (isIdentical(r1, r2))             System.out.println("Yes");         else             System.out.println("No");     } }

Python

# Python program to see if two trees are identical # using DFS class Node:     def __init__(self, val):         self.data = val         self.left = None         self.right = None  # Function to check if two trees are identical def isIdentical(r1, r2):      # If both trees are empty, they are identical     if r1 is None and r2 is None:         return True      # If only one tree is empty, they are not identical     if r1 is None or r2 is None:         return False      # Check if the root data is the same and     # recursively check for the left and right subtrees     return (r1.data == r2.data and             isIdentical(r1.left, r2.left) and             isIdentical(r1.right, r2.right))  if __name__ == "__main__":      # Representation of input binary tree 1     #        1     #       / \     #      2   3     #     /     #    4     r1 = Node(1)     r1.left = Node(2)     r1.right = Node(3)     r1.left.left = Node(4)      # Representation of input binary tree 2     #        1     #       / \     #      2   3     #     /     #    4     r2 = Node(1)     r2.left = Node(2)     r2.right = Node(3)     r2.left.left = Node(4)      if isIdentical(r1, r2):         print("Yes")     else:         print("No")

C#

// C# program to see if two trees are identical // using DFS using System;  class Node {     public int Data;     public Node left, right;      public Node(int val) {         Data = val;         left = right = null;     } }  class GfG {      // Function to check if two trees are identical     static bool isIdentical(Node r1, Node r2) {          // If both trees are empty, they are identical         if (r1 == null && r2 == null)             return true;          // If only one tree is empty, they are not identical         if (r1 == null || r2 == null)             return false;          // Check if the root data is the same and         // recursively check for the left and right subtrees         return (r1.Data == r2.Data) &&                isIdentical(r1.left, r2.left) &&                isIdentical(r1.right, r2.right);     }      static void Main(string[] args) {          // Representation of input binary tree 1         //        1         //       / \         //      2   3         //     /         //    4         Node r1 = new Node(1);         r1.left = new Node(2);         r1.right = new Node(3);         r1.left.left = new Node(4);          // Representation of input binary tree 2         //        1         //       / \         //      2   3         //     /         //    4         Node r2 = new Node(1);         r2.left = new Node(2);         r2.right = new Node(3);         r2.left.left = new Node(4);          if (isIdentical(r1, r2))             Console.WriteLine("Yes");         else             Console.WriteLine("No");     } }

JavaScript

// Javascript program to see if two trees are identical // using DFS class Node {     constructor(val) {         this.data = val;         this.left = null;         this.right = null;     } }  // Function to check if two trees are identical function isIdentical(r1, r2) {      // If both trees are empty, they are identical     if (r1 === null && r2 === null)         return true;      // If only one tree is empty, they are not identical     if (r1 === null || r2 === null)         return false;      // Check if the root data is the same and     // recursively check for the left and right subtrees     return (r1.data === r2.data &&             isIdentical(r1.left, r2.left) &&             isIdentical(r1.right, r2.right)); }  // Representation of input binary tree 1 //        1 //       / \ //      2   3 //     / //    4 let r1 = new Node(1); r1.left = new Node(2); r1.right = new Node(3); r1.left.left = new Node(4);  // Representation of input binary tree 2 //        1 //       / \ //      2   3 //     / //    4 let r2 = new Node(1); r2.left = new Node(2); r2.right = new Node(3); r2.left.left = new Node(4);  if (isIdentical(r1, r2)) {     console.log("Yes"); }  else {     console.log("No"); }

Output

Yes

Time Complexity: O(n), where n is the number of nodes in the larger of the two trees, as each node is visited once.
Auxiliary Space: O(h), where h is the height of the trees, due to the recursive call stack.

[Expected Approach – 2] Using Level Order Traversal (BFS) – O(n) Time and O(n) Space

The idea is to use level order traversal with two queues to compare the structure and data of two trees. By enqueuing nodes from both trees simultaneously, we can compare corresponding nodes at each level. If nodes at any level differ in data or structure, or if one tree has nodes where the other does not, the trees are not identical. This approach ensures that the trees are identical in both structure and node values if all nodes match and the queues are empty at the end.

Follow the below steps to implement the above idea:

Enqueue the root nodes of both trees into a queue.
While the queue is not empty, dequeue the front nodes of both trees and compare their values.
If the values are not equal, return false.
If the values are equal, enqueue the left and right child nodes of both trees, if they exist, into the queue.
Repeat steps 2-4 until either the queue becomes empty or we find two nodes with unequal values.
If the queue becomes empty and we have not found any nodes with unequal values, return true indicating that the trees are identical.

Below is the implementation of the above approach:

C++

// C++ program to see if two trees are identical // using Level Order Traversal(BFS) #include <bits/stdc++.h> using namespace std;  struct Node {     int data;     Node *left, *right;        Node(int val) {         data = val;         left = right = nullptr;     } };  // Function to check if two trees are identical  // using level order traversal bool isIdentical(Node* r1, Node* r2) {     if (r1 == nullptr && r2 == nullptr)         return true;      if (r1 == nullptr || r2 == nullptr)         return false;      // Use two queues for level order traversal     queue<Node*> q1, q2;     q1.push(r1);     q2.push(r2);      while (!q1.empty() && !q2.empty()) {         Node* node1 = q1.front();         Node* node2 = q2.front();         q1.pop();         q2.pop();          // Check if the current nodes are identical         if (node1->data != node2->data)             return false;          // Check the left children         if (node1->left && node2->left) {             q1.push(node1->left);             q2.push(node2->left);         } else if (node1->left || node2->left) {             return false;         }          // Check the right children         if (node1->right && node2->right) {             q1.push(node1->right);             q2.push(node2->right);         } else if (node1->right || node2->right) {             return false;         }     }      // If both queues are empty, the trees are identical     return q1.empty() && q2.empty(); }  int main() {      // Representation of input binary tree 1     //        1     //       / \     //      2   3     //     /     //    4     Node* r1 = new Node(1);         r1->left = new Node(2);        r1->right = new Node(3);      r1->left->left = new Node(4);       // Representation of input binary tree 2     //        1     //       / \     //      2   3     //     /     //    4     Node* r2 = new Node(1);         r2->left = new Node(2);        r2->right = new Node(3);       r2->left->left = new Node(4);      if (isIdentical(r1, r2))         cout << "Yes\n";     else         cout << "No\n";      return 0; }

Java

// Java program to see if two trees are identical // using Level Order Traversal(BFS) import java.util.LinkedList; import java.util.Queue;  class Node {     int data;     Node left, right;      Node(int val) {         data = val;         left = right = null;     } }  class GfG {      // Function to check if two trees are identical     // using level-order traversal     static boolean isIdentical(Node r1, Node r2) {          // If both trees are empty, they are identical         if (r1 == null && r2 == null)             return true;          // If one tree is empty and the other is not         if (r1 == null || r2 == null)             return false;          // Queues to store nodes for level-order traversal         Queue<Node> q1 = new LinkedList<>();         Queue<Node> q2 = new LinkedList<>();          q1.add(r1);         q2.add(r2);          // Perform level-order traversal for both trees         while (!q1.isEmpty() && !q2.isEmpty()) {              Node n1 = q1.poll();             Node n2 = q2.poll();              // Check if the current nodes are not equal             if (n1.data != n2.data)                 return false;              // Check left children             if (n1.left != null && n2.left != null) {                 q1.add(n1.left);                 q2.add(n2.left);             }              else if (n1.left != null || n2.left != null) {                 return false;             }              // Check right children             if (n1.right != null && n2.right != null) {                 q1.add(n1.right);                 q2.add(n2.right);             }              else if (n1.right != null || n2.right != null) {                 return false;             }         }          // Both queues should be empty if trees are identical         return q1.isEmpty() && q2.isEmpty();     }      public static void main(String[] args) {          // Representation of input binary tree 1         //        1         //       / \         //      2   3         //     /         //    4         Node r1 = new Node(1);         r1.left = new Node(2);         r1.right = new Node(3);         r1.left.left = new Node(4);          // Representation of input binary tree 2         //        1         //       / \         //      2   3         //     /         //    4         Node r2 = new Node(1);         r2.left = new Node(2);         r2.right = new Node(3);         r2.left.left = new Node(4);          if (isIdentical(r1, r2))             System.out.println("Yes");         else             System.out.println("No");     } }

Python

# Python program to see if two trees are identical # using Level Order Traversal(BFS) from collections import deque  class Node:     def __init__(self, val):         self.data = val         self.left = None         self.right = None  # Function to check if two trees are identical  # using level-order traversal def isIdentical(r1, r2):      # If both trees are empty, they are identical     if r1 is None and r2 is None:         return True      # If one tree is empty and the other is not     if r1 is None or r2 is None:         return False      # Queues for level-order traversal     q1 = deque([r1])     q2 = deque([r2])      # Perform level-order traversal for both trees     while q1 and q2:          n1 = q1.popleft()         n2 = q2.popleft()          # Check if the current nodes are not equal         if n1.data != n2.data:             return False          # Check left children         if n1.left and n2.left:             q1.append(n1.left)             q2.append(n2.left)                      elif n1.left or n2.left:             return False          # Check right children         if n1.right and n2.right:             q1.append(n1.right)             q2.append(n2.right)                      elif n1.right or n2.right:             return False      # Both queues should be empty if trees are identical     return not q1 and not q2  if __name__ == "__main__":      # Representation of input binary tree 1     #        1     #       / \     #      2   3     #     /     #    4     r1 = Node(1)     r1.left = Node(2)     r1.right = Node(3)     r1.left.left = Node(4)      # Representation of input binary tree 2     #        1     #       / \     #      2   3     #     /     #    4     r2 = Node(1)     r2.left = Node(2)     r2.right = Node(3)     r2.left.left = Node(4)      if isIdentical(r1, r2):         print("Yes")     else:         print("No")

C#

// C# program to see if two trees are identical // using Level Order Traversal(BFS) using System; using System.Collections.Generic;  class Node {     public int data;     public Node left, right;      public Node(int val) {         data = val;         left = right = null;     } }  class GfG {      // Function to check if two trees are identical      // using level-order traversal     static bool IsIdentical(Node r1, Node r2) {          // If both trees are empty, they are identical         if (r1 == null && r2 == null)             return true;          // If one tree is empty and the other is not         if (r1 == null || r2 == null)             return false;          // Queues for level-order traversal         Queue<Node> q1 = new Queue<Node>();         Queue<Node> q2 = new Queue<Node>();          q1.Enqueue(r1);         q2.Enqueue(r2);          // Perform level-order traversal for both trees         while (q1.Count > 0 && q2.Count > 0) {             Node n1 = q1.Dequeue();             Node n2 = q2.Dequeue();              // Check if the current nodes' data are not equal             if (n1.data != n2.data)                 return false;              // Check left children             if (n1.left != null && n2.left != null) {                 q1.Enqueue(n1.left);                 q2.Enqueue(n2.left);             }              else if (n1.left != null || n2.left != null) {                 return false;             }              // Check right children             if (n1.right != null && n2.right != null) {                 q1.Enqueue(n1.right);                 q2.Enqueue(n2.right);             }              else if (n1.right != null || n2.right != null) {                 return false;             }         }          // Both queues should be empty if trees are          // identical         return q1.Count == 0 && q2.Count == 0;     }      static void Main(string[] args) {          // Representation of input binary tree 1         //        1         //       / \         //      2   3         //     /         //    4         Node r1 = new Node(1);         r1.left = new Node(2);         r1.right = new Node(3);         r1.left.left = new Node(4);          // Representation of input binary tree 2         //        1         //       / \         //      2   3         //     /         //    4         Node r2 = new Node(1);         r2.left = new Node(2);         r2.right = new Node(3);         r2.left.left = new Node(4);          if (IsIdentical(r1, r2))             Console.WriteLine("Yes");         else             Console.WriteLine("No");     } }

JavaScript

// Javascript program to see if two trees are identical // using Level Order Traversal(BFS) class Node {     constructor(val) {         this.data = val;         this.left = null;         this.right = null;     } }  // Function to check if two trees are identical // using level-order traversal function isIdentical(r1, r2) {      // If both trees are empty, they are identical     if (r1 === null && r2 === null)         return true;      // If one tree is empty and the other is not     if (r1 === null || r2 === null)         return false;      // Queues for level-order traversal     let queue1 = [r1];     let queue2 = [r2];      // Perform level-order traversal for both trees     while (queue1.length > 0 && queue2.length > 0) {         let node1 = queue1.shift();         let node2 = queue2.shift();          // Check if the current nodes' data are not equal         if (node1.data !== node2.data)             return false;          // Check left children         if (node1.left && node2.left) {             queue1.push(node1.left);             queue2.push(node2.left);         }          else if (node1.left || node2.left) {             return false;         }          // Check right children         if (node1.right && node2.right) {             queue1.push(node1.right);             queue2.push(node2.right);         }          else if (node1.right || node2.right) {             return false;         }     }      // Both queues should be empty if trees are identical     return queue1.length === 0 && queue2.length === 0; }  // Representation of input binary tree 1 //        1 //       / \ //      2   3 //     / //    4 let r1 = new Node(1); r1.left = new Node(2); r1.right = new Node(3); r1.left.left = new Node(4);  // Representation of input binary tree 2 //        1 //       / \ //      2   3 //     / //    4 let r2 = new Node(1); r2.left = new Node(2); r2.right = new Node(3); r2.left.left = new Node(4);  if (isIdentical(r1, r2)) {     console.log("Yes"); }  else {     console.log("No"); }

Output

Yes

Time complexity: O(n), where n is the number of nodes in the larger of the two trees, as each node is visited once.
Auxiliary Space: O(w), where w is the maximum width of the trees at any level, due to the space required for the queues.

[Expected Approach – 3] Using Morris Traversal – O(n) Time and O(1) Space

The idea is to use Morris traversal for comparing two trees, traverse both trees simultaneously by starting at their roots. For each node, if the left subtree exists, find the rightmost node in the left subtree (the predecessor) and create a temporary link back to the current node. Then, move to the left subtree. If no left subtree exists, compare the current nodes of both trees and move to the right subtree. At each step, compare the values of the corresponding nodes and ensure the structure matches. If at any point the values or structure differ, the trees are not identical. The process continues until both trees are fully traversed, and any temporary links created are removed. If no mismatches are found, the trees are identical.

Follow the steps to implement the above idea:

Check if both trees are empty. If they are, return true. If only one of them is empty, return false.
Perform the Morris traversal for in-order traversal of both trees simultaneously. At each step, compare the nodes visited in both trees.
If at any step, the nodes visited in both trees are not equal, return false.
If we reach the end of both trees simultaneously (i.e., both nodes are NULL), return true.

Below is the implementation of the above approach:

C++

// C++ program to see if two trees are identical // using Morris Traversal #include <bits/stdc++.h> using namespace std;  struct Node {     int data;     Node *left, *right;      Node(int val) {         data = val;         left = right = nullptr;     } };  // Function to check if two trees are  // identical using Morris traversal bool isIdentical(Node* r1, Node* r2) {      // Check if both trees are empty     if (r1 == nullptr && r2 == nullptr)         return true;      // Check if one tree is empty and the other is not     if (r1 == nullptr || r2 == nullptr)         return false;      // Morris traversal to compare both trees     while (r1 != nullptr && r2 != nullptr) {          // Compare the data of both current nodes         if (r1->data != r2->data)             return false;          // Morris traversal for the first tree (r1)         if (r1->left == nullptr) {                          // Move to the right child if no left child             r1 = r1->right;         } else {                          // Find the inorder predecessor of r1             Node* pre = r1->left;             while (pre->right != nullptr                 && pre->right != r1) {                 pre = pre->right;             }              // Set the temporary link to r1             if (pre->right == nullptr) {                 pre->right = r1;                 r1 = r1->left;             }                         // Remove the temporary link and move to right             else {                 pre->right = nullptr;                 r1 = r1->right;             }         }          // Morris traversal for the second tree (r2)         if (r2->left == nullptr) {                          // Move to the right child if no left child             r2 = r2->right;         } else {                          // Find the inorder predecessor of r2             Node* pre = r2->left;             while (pre->right != nullptr                 && pre->right != r2) {                 pre = pre->right;             }              // Set the temporary link to r2             if (pre->right == nullptr) {                 pre->right = r2;                 r2 = r2->left;             }                         // Remove the temporary link and move to right             else {                 pre->right = nullptr;                 r2 = r2->right;             }         }     }      // Both trees are identical if both are null at end     return (r1 == nullptr && r2 == nullptr); }  int main() {      // Representation of input binary tree 1     //        1     //       / \     //      2   3     //     /     //    4     Node* r1 = new Node(1);     r1->left = new Node(2);     r1->right = new Node(3);     r1->left->left = new Node(4);      // Representation of input binary tree 2     //        1     //       / \     //      2   3     //     /     //    4     Node* r2 = new Node(1);     r2->left = new Node(2);     r2->right = new Node(3);     r2->left->left = new Node(4);      if (isIdentical(r1, r2))         cout << "Yes\n";     else         cout << "No\n";      return 0; }

C

// C program to see if two trees are identical // using Morris Traversal #include <stdio.h> #include <stdlib.h>  struct Node {     int data;     struct Node *left, *right; };  // Function to check if two trees are identical  // using Morris traversal int isIdentical(struct Node* r1, struct Node* r2) {      // Check if both trees are empty     if (r1 == NULL && r2 == NULL)         return 1;      // Check if one tree is empty and the other is not     if (r1 == NULL || r2 == NULL)         return 0;      // Morris traversal to compare both trees     while (r1 != NULL && r2 != NULL) {          // Compare the data of both current nodes         if (r1->data != r2->data)             return 0;          // Morris traversal for the first tree (r1)         if (r1->left == NULL) {                        // Move to the right child if no left child             r1 = r1->right;         } else {                        // Find the inorder predecessor of r1             struct Node* pre = r1->left;             while (pre->right != NULL && pre->right != r1) {                 pre = pre->right;             }              // Set the temporary link to r1             if (pre->right == NULL) {                 pre->right = r1;                 r1 = r1->left;             }                         // Remove the temporary link and move to right             else {                 pre->right = NULL;                 r1 = r1->right;             }         }          // Morris traversal for the second tree (r2)         if (r2->left == NULL) {                        // Move to the right child if no left child             r2 = r2->right;         } else {                        // Find the inorder predecessor of r2             struct Node* pre = r2->left;             while (pre->right != NULL && pre->right != r2) {                 pre = pre->right;             }              // Set the temporary link to r2             if (pre->right == NULL) {                 pre->right = r2;                 r2 = r2->left;             }                         // Remove the temporary link and move to right             else {                 pre->right = NULL;                 r2 = r2->right;             }         }     }      // Both trees are identical if both are      // null at the end     return (r1 == NULL && r2 == NULL); }  struct Node* createNode(int val) {     struct Node* node        = (struct Node*)malloc(sizeof(struct Node));     node->data = val;     node->left = node->right = NULL;     return node; }  int main() {      // Representation of input binary tree 1     //        1     //       / \     //      2   3     //     /     //    4     struct Node* r1 = createNode(1);     r1->left = createNode(2);     r1->right = createNode(3);     r1->left->left = createNode(4);      // Representation of input binary tree 2     //        1     //       / \     //      2   3     //     /     //    4     struct Node* r2 = createNode(1);     r2->left = createNode(2);     r2->right = createNode(3);     r2->left->left = createNode(4);      if (isIdentical(r1, r2))         printf("Yes\n");     else         printf("No\n");      return 0; }

Java

// Java program to see if two trees are identical // using Morris Traversal import java.util.*;  class Node {     int data;     Node left, right;      Node(int val) {         data = val;         left = right = null;     } }  class GfG {      // Function to check if two trees are identical     // using Morris traversal     static boolean isIdentical(Node r1, Node r2) {          // Check if both trees are empty         if (r1 == null && r2 == null)             return true;          // Check if one tree is empty and the other is not         if (r1 == null || r2 == null)             return false;          // Morris traversal to compare both trees         while (r1 != null && r2 != null) {              // Compare the data of both current nodes             if (r1.data != r2.data)                 return false;              // Morris traversal for the first tree (r1)             if (r1.left == null) {                  // Move to the right child if no left child                 r1 = r1.right;             }              else {                  // Find the inorder predecessor of r1                 Node pre = r1.left;                 while (pre.right != null && pre.right != r1) {                     pre = pre.right;                 }                  // Set the temporary link to r1                 if (pre.right == null) {                     pre.right = r1;                     r1 = r1.left;                 }                   // Remove the temporary link and move to right                 else {                     pre.right = null;                     r1 = r1.right;                 }             }              // Morris traversal for the second tree (r2)             if (r2.left == null) {                  // Move to the right child if no left child                 r2 = r2.right;             }              else {                  // Find the inorder predecessor of r2                 Node pre = r2.left;                 while (pre.right != null && pre.right != r2) {                     pre = pre.right;                 }                  // Set the temporary link to r2                 if (pre.right == null) {                     pre.right = r2;                     r2 = r2.left;                 }                   // Remove the temporary link and move to right                 else {                     pre.right = null;                     r2 = r2.right;                 }             }         }          // Both trees are identical if both are          // null at the end         return (r1 == null && r2 == null);     }      public static void main(String[] args) {          // Representation of input binary tree 1         //        1         //       / \         //      2   3         //     /         //    4         Node r1 = new Node(1);         r1.left = new Node(2);         r1.right = new Node(3);         r1.left.left = new Node(4);          // Representation of input binary tree 2         //        1         //       / \         //      2   3         //     /         //    4         Node r2 = new Node(1);         r2.left = new Node(2);         r2.right = new Node(3);         r2.left.left = new Node(4);          if (isIdentical(r1, r2))             System.out.println("Yes");         else             System.out.println("No");     } }

Python

# Python program to see if two trees are identical # using Morris Traversal class Node:     def __init__(self, val):         self.data = val         self.left = None         self.right = None  # Function to check if two trees are identical  # using Morris traversal def isIdentical(r1, r2):      # Check if both trees are empty     if r1 is None and r2 is None:         return True      # Check if one tree is empty and the other is not     if r1 is None or r2 is None:         return False      # Morris traversal to compare both trees     while r1 is not None and r2 is not None:          # Compare the data of both current nodes         if r1.data != r2.data:             return False          # Morris traversal for the first tree (r1)         if r1.left is None:              # Move to the right child if no left child             r1 = r1.right         else:              # Find the inorder predecessor of r1             pre = r1.left             while pre.right is not None and pre.right != r1:                 pre = pre.right              # Set the temporary link to r1             if pre.right is None:                 pre.right = r1                 r1 = r1.left              # Remove the temporary link and move to right             else:                 pre.right = None                 r1 = r1.right          # Morris traversal for the second tree (r2)         if r2.left is None:              # Move to the right child if no left child             r2 = r2.right         else:              # Find the inorder predecessor of r2             pre = r2.left             while pre.right is not None and pre.right != r2:                 pre = pre.right              # Set the temporary link to r2             if pre.right is None:                 pre.right = r2                 r2 = r2.left              # Remove the temporary link and move to right             else:                 pre.right = None                 r2 = r2.right      # Both trees are identical if both are null at end     return r1 is None and r2 is None  if __name__ == '__main__':        # Representation of input binary tree 1     #        1     #       / \     #      2   3     #     /     #    4     r1 = Node(1)     r1.left = Node(2)     r1.right = Node(3)     r1.left.left = Node(4)      # Representation of input binary tree 2     #        1     #       / \     #      2   3     #     /     #    4     r2 = Node(1)     r2.left = Node(2)     r2.right = Node(3)     r2.left.left = Node(4)      if isIdentical(r1, r2):         print("Yes")     else:         print("No")

C#

// C# program to see if two trees are identical // using Morris Traversal using System;  class Node {     public int data;     public Node left, right;        public Node(int val) {         data = val;         left = right = null;     } }  class GfG {      // Function to check if two trees are identical      // using Morris traversal     static bool IsIdentical(Node r1, Node r2) {          // Check if both trees are empty         if (r1 == null && r2 == null)             return true;          // Check if one tree is empty and the other is not         if (r1 == null || r2 == null)             return false;          // Morris traversal to compare both trees         while (r1 != null && r2 != null) {              // Compare the data of both current nodes             if (r1.data != r2.data)                 return false;              // Morris traversal for the first tree (r1)             if (r1.left == null) {                  // Move to the right child if no left child                 r1 = r1.right;             }              else {                  // Find the inorder predecessor of r1                 Node pre = r1.left;                 while (pre.right != null && pre.right != r1) {                     pre = pre.right;                 }                  // Set the temporary link to r1                 if (pre.right == null) {                     pre.right = r1;                     r1 = r1.left;                 }                   // Remove the temporary link and move to right                 else {                     pre.right = null;                     r1 = r1.right;                 }             }              // Morris traversal for the second tree (r2)             if (r2.left == null) {                  // Move to the right child if no left child                 r2 = r2.right;             }              else {                  // Find the inorder predecessor of r2                 Node pre = r2.left;                 while (pre.right != null && pre.right != r2) {                     pre = pre.right;                 }                  // Set the temporary link to r2                 if (pre.right == null) {                     pre.right = r2;                     r2 = r2.left;                 }                   // Remove the temporary link and move to right                 else {                     pre.right = null;                     r2 = r2.right;                 }             }         }          // Both trees are identical if both are         // null at end         return (r1 == null && r2 == null);     }      static void Main(string[] args) {          // Representation of input binary tree 1         //        1         //       / \         //      2   3         //     /         //    4         Node r1 = new Node(1);         r1.left = new Node(2);         r1.right = new Node(3);         r1.left.left = new Node(4);          // Representation of input binary tree 2         //        1         //       / \         //      2   3         //     /         //    4         Node r2 = new Node(1);         r2.left = new Node(2);         r2.right = new Node(3);         r2.left.left = new Node(4);          if (IsIdentical(r1, r2))             Console.WriteLine("Yes");         else             Console.WriteLine("No");     } }

JavaScript

// Javascript program to see if two trees are identical // using Morris Traversal class Node {     constructor(val) {         this.data = val;         this.left = null;         this.right = null;     } }  // Function to check if two trees are identical  // using Morris traversal function isIdentical(r1, r2) {      // Check if both trees are empty     if (r1 === null && r2 === null) {         return true;     }      // Check if one tree is empty and the other is not     if (r1 === null || r2 === null) {         return false;     }      // Morris traversal to compare both trees     while (r1 !== null && r2 !== null) {          // Compare the data of both current nodes         if (r1.data !== r2.data) {             return false;         }          // Morris traversal for the first tree (r1)         if (r1.left === null) {              // Move to the right child if no left child             r1 = r1.right;         }          else {              // Find the inorder predecessor of r1             let pre = r1.left;             while (pre.right !== null && pre.right !== r1) {                 pre = pre.right;             }              // Set the temporary link to r1             if (pre.right === null) {                 pre.right = r1;                 r1 = r1.left;             }                           // Remove the temporary link and move to right             else {                 pre.right = null;                 r1 = r1.right;             }         }          // Morris traversal for the second tree (r2)         if (r2.left === null) {              // Move to the right child if no left child             r2 = r2.right;         }          else {              // Find the inorder predecessor of r2             let pre = r2.left;             while (pre.right !== null && pre.right !== r2) {                 pre = pre.right;             }              // Set the temporary link to r2             if (pre.right === null) {                 pre.right = r2;                 r2 = r2.left;             }                           // Remove the temporary link and move to right             else {                 pre.right = null;                 r2 = r2.right;             }         }     }      // Both trees are identical if both are null at end     return r1 === null && r2 === null; }  // Representation of input binary tree 1 //        1 //       / \ //      2   3 //     / //    4 let r1 = new Node(1); r1.left = new Node(2); r1.right = new Node(3); r1.left.left = new Node(4);  // Representation of input binary tree 2 //        1 //       / \ //      2   3 //     / //    4 let r2 = new Node(1); r2.left = new Node(2); r2.right = new Node(3); r2.left.left = new Node(4);  if (isIdentical(r1, r2)) {     console.log("Yes"); }  else {     console.log("No"); }

Output

Yes

Time Complexity: O(n), where n is the number of nodes in the larger of the two trees, as each node is visited once.
Auxiliary Space: O(1), Morris traversal modifies the tree temporarily by establishing “threads” to traverse nodes without using recursion or a stack.

Subtree with given sum in a Binary Tree

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. Representation of Binary TreeEach node in a Binar

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 levels Note: Height of root node is considered as 0. Properties of Binary Trees1. Maximum Nodes at Level 'l'A binary tree can have at most

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 h

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:

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