# Iterative function to check if two trees are identical

Two trees are identical when they have same data and arrangement of data is also same. To identify if two trees are identical, we need to traverse both trees simultaneously, and while traversing we need to compare data and children of the trees.
Examples:

`Input : Roots of below trees    10           10  /   \         / 5     6       5 Output : falseInput : Roots of below trees    10            10  /   \         /   \ 5     6       5     6Output : true`

We have discussed recursive solution here. In this article iterative solution is discussed.
The idea is to use level order traversal. We traverse both trees simultaneously and compare the data whenever we dequeue and item from queue. Below is the implementation of the idea.

## C++

 `/* Iterative C++ program to check if two */``#include ``using` `namespace` `std;` `// A Binary Tree Node``struct` `Node``{``    ``int` `data;``    ``struct` `Node *left, *right;``};` `// Iterative method to find height of Binary Tree``bool` `areIdentical(Node *root1, Node *root2)``{``    ``// Return true if both trees are empty``    ``if` `(root1==NULL  && root2==NULL) ``return` `true``;` `    ``// Return false if one is empty and other is not``    ``if` `(root1 == NULL) ``return` `false``;``    ``if` `(root2 == NULL) ``return` `false``;``    ` `    ``// Create an empty queues for simultaneous traversals ``    ``queue q1, q2;` `    ``// Enqueue Roots of trees in respective queues``    ``q1.push(root1);``    ``q2.push(root2);` `    ``while` `(!q1.empty() && !q2.empty())``    ``{``        ``// Get front nodes and compare them``        ``Node *n1 = q1.front();``        ``Node *n2 = q2.front();` `        ``if` `(n1->data != n2->data)``           ``return` `false``;` `        ``// Remove front nodes from queues``        ``q1.pop(), q2.pop();` `        ``/* Enqueue left children of both nodes */``        ``if` `(n1->left && n2->left)``        ``{``            ``q1.push(n1->left);``            ``q2.push(n2->left);``        ``}` `        ``// If one left child is empty and other is not``        ``else` `if` `(n1->left || n2->left)``            ``return` `false``;` `        ``// Right child code (Similar to left child code)``        ``if` `(n1->right && n2->right)``        ``{``            ``q1.push(n1->right);``            ``q2.push(n2->right);``        ``}``        ``else` `if` `(n1->right || n2->right)``            ``return` `false``;``    ``}` `    ``return` `true``;``}` `// Utility function to create a new tree node``Node* newNode(``int` `data)``{``    ``Node *temp = ``new` `Node;``    ``temp->data = data;``    ``temp->left = temp->right = NULL;``    ``return` `temp;``}` `// Driver program to test above functions``int` `main()``{``    ``Node *root1 = newNode(1);``    ``root1->left = newNode(2);``    ``root1->right = newNode(3);``    ``root1->left->left = newNode(4);``    ``root1->left->right = newNode(5);` `    ``Node *root2 = newNode(1);``    ``root2->left = newNode(2);``    ``root2->right = newNode(3);``    ``root2->left->left = newNode(4);``    ``root2->left->right = newNode(5);` `    ``areIdentical(root1, root2)? cout << ``"Yes"``                              ``: cout << ``"No"``;``    ``return` `0;``}`

## Java

 `/* Iterative Java program to check if two */``import` `java.util.*;``class` `GfG {` `// A Binary Tree Node ``static` `class` `Node ``{ ``    ``int` `data; ``    ``Node left, right; ``}` `// Iterative method to find height of Binary Tree ``static` `boolean` `areIdentical(Node root1, Node root2) ``{ ``    ``// Return true if both trees are empty ``    ``if` `(root1 == ``null` `&& root2 == ``null``)  ``return` `true``; ` `    ``// Return false if one is empty and other is not ``    ``if` `(root1 == ``null` `|| root2 == ``null``) ``return` `false``; ` `    ``// Create an empty queues for simultaneous traversals ``    ``Queue q1 = ``new` `LinkedList ();``    ``Queue  q2 = ``new` `LinkedList (); ` `    ``// Enqueue Roots of trees in respective queues ``    ``q1.add(root1); ``    ``q2.add(root2); ` `    ``while` `(!q1.isEmpty() && !q2.isEmpty()) ``    ``{ ``        ``// Get front nodes and compare them ``        ``Node n1 = q1.peek(); ``        ``Node n2 = q2.peek(); ` `        ``if` `(n1.data != n2.data) ``        ``return` `false``; ` `        ``// Remove front nodes from queues ``        ``q1.remove();``        ``q2.remove(); ` `        ``/* Enqueue left children of both nodes */``        ``if` `(n1.left != ``null` `&& n2.left != ``null``) ``        ``{ ``            ``q1.add(n1.left); ``            ``q2.add(n2.left); ``        ``} ` `        ``// If one left child is empty and other is not ``        ``else` `if` `(n1.left != ``null` `|| n2.left != ``null``) ``            ``return` `false``; ` `        ``// Right child code (Similar to left child code) ``        ``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``; ``    ``} ` `    ``return` `true``; ``} ` `// Utility function to create a new tree node ``static` `Node newNode(``int` `data) ``{ ``    ``Node temp = ``new` `Node(); ``    ``temp.data = data; ``    ``temp.left = ``null``;``    ``temp.right = ``null``; ``    ``return` `temp; ``} ` `// Driver program to test above functions ``public` `static` `void` `main(String[] args) ``{ ``    ``Node root1 = newNode(``1``); ``    ``root1.left = newNode(``2``); ``    ``root1.right = newNode(``3``); ``    ``root1.left.left = newNode(``4``); ``    ``root1.left.right = newNode(``5``); ` `    ``Node root2 = newNode(``1``); ``    ``root2.left = newNode(``2``); ``    ``root2.right = newNode(``3``); ``    ``root2.left.left = newNode(``4``); ``    ``root2.left.right = newNode(``5``); ` `    ``if``(areIdentical(root1, root2) == ``true``)``    ``System.out.println(``"Yes"``);``    ``else``    ``System.out.println(``"No"``);``}``} `

## Python3

 `# Iterative Python3 program to check ``# if two trees are identical``from` `queue ``import` `Queue ` `# Utility function to create a ``# new tree node ``class` `newNode:``    ``def` `__init__(``self``, data):``        ``self``.data ``=` `data ``        ``self``.left ``=` `self``.right ``=` `None` `# Iterative method to find height of ``# Binary Tree ``def` `areIdentical(root1, root2):``    ` `    ``# Return true if both trees are empty ``    ``if` `(root1 ``and` `root2):``        ``return` `True` `    ``# Return false if one is empty and``    ``# other is not ``    ``if` `(root1 ``or` `root2):``        ``return` `False` `    ``# Create an empty queues for ``    ``# simultaneous traversals ``    ``q1 ``=` `Queue()``    ``q2 ``=` `Queue()` `    ``# Enqueue Roots of trees in ``    ``# respective queues ``    ``q1.put(root1) ``    ``q2.put(root2) ` `    ``while` `(``not` `q1.empty() ``and` `not` `q2.empty()):``        ` `        ``# Get front nodes and compare them ``        ``n1 ``=` `q1.queue[``0``]``        ``n2 ``=` `q2.queue[``0``]` `        ``if` `(n1.data !``=` `n2.data): ``            ``return` `False` `        ``# Remove front nodes from queues ``        ``q1.get()``        ``q2.get() ` `        ``# Enqueue left children of both nodes ``        ``if` `(n1.left ``and` `n2.left):``            ``q1.put(n1.left) ``            ``q2.put(n2.left)` `        ``# If one left child is empty and``        ``# other is not ``        ``elif` `(n1.left ``or` `n2.left): ``            ``return` `False` `        ``# Right child code (Similar to ``        ``# left child code) ``        ``if` `(n1.right ``and` `n2.right):``            ``q1.put(n1.right) ``            ``q2.put(n2.right)``        ``elif` `(n1.right ``or` `n2.right): ``            ``return` `False` `    ``return` `True` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``    ``root1 ``=` `newNode(``1``) ``    ``root1.left ``=` `newNode(``2``) ``    ``root1.right ``=` `newNode(``3``) ``    ``root1.left.left ``=` `newNode(``4``) ``    ``root1.left.right ``=` `newNode(``5``) ` `    ``root2 ``=` `newNode(``1``) ``    ``root2.left ``=` `newNode(``2``) ``    ``root2.right ``=` `newNode(``3``) ``    ``root2.left.left ``=` `newNode(``4``) ``    ``root2.left.right ``=` `newNode(``5``) ` `    ``if` `areIdentical(root1, root2):``        ``print``(``"Yes"``)``    ``else``:``        ``print``(``"No"``)``        ` `# This code is contributed by PranchalK`

## C#

 `/* Iterative C# program to check if two */``using` `System;``using` `System.Collections.Generic;` `class` `GfG ``{ ` `// A Binary Tree Node ``class` `Node ``{ ``    ``public` `int` `data; ``    ``public` `Node left, right; ``} ` `// Iterative method to find height of Binary Tree ``static` `bool` `areIdentical(Node root1, Node root2) ``{ ``    ``// Return true if both trees are empty ``    ``if` `(root1 == ``null` `&& root2 == ``null``) ``        ``return` `true``; ` `    ``// Return false if one is empty and other is not ``    ``if` `(root1 == ``null` `|| root2 == ``null``) ``        ``return` `false``; ` `    ``// Create an empty queues for ``    ``// simultaneous traversals ``    ``Queue q1 = ``new` `Queue (); ``    ``Queue q2 = ``new` `Queue (); ` `    ``// Enqueue Roots of trees in respective queues ``    ``q1.Enqueue(root1); ``    ``q2.Enqueue(root2); ` `    ``while` `(q1.Count != 0 && q2.Count != 0) ``    ``{ ``        ``// Get front nodes and compare them ``        ``Node n1 = q1.Peek(); ``        ``Node n2 = q2.Peek(); ` `        ``if` `(n1.data != n2.data) ``        ``return` `false``; ` `        ``// Remove front nodes from queues ``        ``q1.Dequeue(); ``        ``q2.Dequeue(); ` `        ``/* Enqueue left children of both nodes */``        ``if` `(n1.left != ``null` `&& n2.left != ``null``) ``        ``{ ``            ``q1.Enqueue(n1.left); ``            ``q2.Enqueue(n2.left); ``        ``} ` `        ``// If one left child is empty and other is not ``        ``else` `if` `(n1.left != ``null` `|| n2.left != ``null``) ``            ``return` `false``; ` `        ``// Right child code (Similar to left child code) ``        ``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``; ``    ``} ` `    ``return` `true``; ``} ` `// Utility function to create a new tree node ``static` `Node newNode(``int` `data) ``{ ``    ``Node temp = ``new` `Node(); ``    ``temp.data = data; ``    ``temp.left = ``null``; ``    ``temp.right = ``null``; ``    ``return` `temp; ``} ` `// Driver code ``public` `static` `void` `Main(String[] args) ``{ ``    ``Node root1 = newNode(1); ``    ``root1.left = newNode(2); ``    ``root1.right = newNode(3); ``    ``root1.left.left = newNode(4); ``    ``root1.left.right = newNode(5); ` `    ``Node root2 = newNode(1); ``    ``root2.left = newNode(2); ``    ``root2.right = newNode(3); ``    ``root2.left.left = newNode(4); ``    ``root2.left.right = newNode(5); ` `    ``if``(areIdentical(root1, root2) == ``true``) ``    ``Console.WriteLine(``"Yes"``); ``    ``else``    ``Console.WriteLine(``"No"``); ``} ``} ` `// This code is contributed by PrinciRaj1992`

## Javascript

 ``

Output
```Yes

```

Time complexity of above solution is O(n + m) where m and n are number of nodes in two trees.

Space complexity: O(n) space for queue
Using Iterative Post-Order Traversal and Two Stacks:

`The basic idea behind this approach is to traverse both trees in a postorder fashion iteratively, and compare their nodes one by one. We can use two stacks to do this. We start with pushing the root nodes of both trees onto their respective stacks. `

Follow the steps to implement the idea:

1. we repeat the following steps until both stacks are empty:
2. Pop the top node from each stack.
3. Compare the popped nodes. If they are not identical, return false.
4. Push the right subtree of both nodes (if they exist) onto their respective stacks.
5. Push the left subtree of both nodes (if they exist) onto their respective stacks.

Below is the implementation of the above approach:

## C++

 `// C++ code to implement Iterative Postorder Traversal using``// two stacks``#include ``#include ``using` `namespace` `std;` `/* A binary tree node */``struct` `Node {``    ``int` `data;``    ``Node *left, *right;``    ``Node(``int` `x)``    ``{``        ``data = x;``        ``left = right = NULL;``    ``}``};` `/* Iterative Postorder Traversal to check if two binary`` ``* trees are identical */``bool` `isIdentical(Node* r1, Node* r2)``{``    ``stack stack1, stack2;` `    ``// loop until both trees are completely traversed``    ``while` `(r1 != NULL || !stack1.empty() || r2 != NULL``           ``|| !stack2.empty()) {``        ``// push all left nodes of first tree in stack1``        ``while` `(r1 != NULL) {``            ``stack1.push(r1);``            ``r1 = r1->left;``        ``}``        ``// push all left nodes of second tree in stack2``        ``while` `(r2 != NULL) {``            ``stack2.push(r2);``            ``r2 = r2->left;``        ``}``        ``// if size of both stacks is different, trees are``        ``// not identical``        ``if` `(stack1.size() != stack2.size())``            ``return` `false``;``        ``// pop one node from each stack and compare their``        ``// data``        ``r1 = stack1.top();``        ``stack1.pop();``        ``r2 = stack2.top();``        ``stack2.pop();``        ``if` `(r1->data != r2->data)``            ``return` `false``;``        ``// move to the right of the popped nodes``        ``r1 = r1->right;``        ``r2 = r2->right;``    ``}``    ``// both trees are identical``    ``return` `true``;``}` `/* Driver code */``int` `main()``{``    ``// Construct the first tree``    ``Node* root1 = ``new` `Node(1);``    ``root1->left = ``new` `Node(2);``    ``root1->right = ``new` `Node(3);``    ``root1->left->left = ``new` `Node(4);``    ``root1->left->right = ``new` `Node(5);` `    ``// Construct the second tree``    ``Node* root2 = ``new` `Node(1);``    ``root2->left = ``new` `Node(2);``    ``root2->right = ``new` `Node(3);``    ``root2->left->left = ``new` `Node(4);``    ``root2->left->right = ``new` `Node(5);` `    ``// Check if the trees are identical``    ``if` `(isIdentical(root1, root2))``        ``cout << ``"Both trees are identical"``;``    ``else``        ``cout << ``"Both trees are not identical"``;` `    ``return` `0;``}``// This code is contributed by Veerendra_Singh_Rajpoot`

## Java

 `import` `java.util.Stack;` `// A Java program to implement Iterative Postorder Traversal using two stacks` `// A binary tree node``class` `Node {``    ``int` `data;``    ``Node left, right;``    ` `    ``// Constructor``    ``Node(``int` `x) {``        ``data = x;``        ``left = right = ``null``;``    ``}``}` `public` `class` `IdenticalBinaryTrees {``    ``// Iterative Postorder Traversal to check if two binary trees are identical``    ``static` `boolean` `isIdentical(Node r1, Node r2) {``        ``Stack stack1 = ``new` `Stack<>();``        ``Stack stack2 = ``new` `Stack<>();``        ` `        ``// loop until both trees are completely traversed``        ``while` `(r1 != ``null` `|| !stack1.empty() || r2 != ``null` `|| !stack2.empty()) {``            ``// push all left nodes of the first tree in stack1``            ``while` `(r1 != ``null``) {``                ``stack1.push(r1);``                ``r1 = r1.left;``            ``}``            ``// push all left nodes of the second tree in stack2``            ``while` `(r2 != ``null``) {``                ``stack2.push(r2);``                ``r2 = r2.left;``            ``}``            ``// if the size of both stacks is different, trees are not identical``            ``if` `(stack1.size() != stack2.size())``                ``return` `false``;``            ``// pop one node from each stack and compare their data``            ``r1 = stack1.pop();``            ``r2 = stack2.pop();``            ``if` `(r1.data != r2.data)``                ``return` `false``;``            ``// move to the right of the popped nodes``            ``r1 = r1.right;``            ``r2 = r2.right;``        ``}``        ``// both trees are identical``        ``return` `true``;``    ``}``//Driver code``    ``public` `static` `void` `main(String[] args) {``        ``// Construct the first tree``        ``Node root1 = ``new` `Node(``1``);``        ``root1.left = ``new` `Node(``2``);``        ``root1.right = ``new` `Node(``3``);``        ``root1.left.left = ``new` `Node(``4``);``        ``root1.left.right = ``new` `Node(``5``);` `        ``// Construct the second tree``        ``Node root2 = ``new` `Node(``1``);``        ``root2.left = ``new` `Node(``2``);``        ``root2.right = ``new` `Node(``3``);``        ``root2.left.left = ``new` `Node(``4``);``        ``root2.left.right = ``new` `Node(``5``);` `        ``// Check if the trees are identical``        ``if` `(isIdentical(root1, root2))``            ``System.out.println(``"Both trees are identical"``);``        ``else``            ``System.out.println(``"Both trees are not identical"``);``    ``}``}`

## Python3

 `# Python code to implement Iterative Postorder Traversal using``# two stacks` `# A class representing a node in the binary tree``class` `Node:``    ``def` `__init__(``self``, data):``        ``self``.data ``=` `data``        ``self``.left ``=` `None``        ``self``.right ``=` `None` `# Iterative Postorder Traversal to check if two binary ``# trees are identical``def` `isIdentical(r1, r2):``    ``stack1 ``=` `[]``    ``stack2 ``=` `[]` `    ``# Loop until both trees are completely traversed``    ``while` `r1 ``or` `stack1 ``or` `r2 ``or` `stack2:``        ``# Push all left nodes of the first tree in stack1``        ``while` `r1:``            ``stack1.append(r1)``            ``r1 ``=` `r1.left` `        ``# Push all left nodes of the second tree in stack2``        ``while` `r2:``            ``stack2.append(r2)``            ``r2 ``=` `r2.left` `        ``# If size of both stacks is different, trees are not identical``        ``if` `len``(stack1) !``=` `len``(stack2):``            ``return` `False` `        ``# Pop one node from each stack and compare their data``        ``r1 ``=` `stack1.pop()``        ``r2 ``=` `stack2.pop()` `        ``if` `r1.data !``=` `r2.data:``            ``return` `False` `        ``# Move to the right of the popped nodes``        ``r1 ``=` `r1.right``        ``r2 ``=` `r2.right` `    ``# Both trees are identical``    ``return` `True` `# Driver code``if` `__name__ ``=``=` `'__main__'``:``    ``# Construct the first tree``    ``root1 ``=` `Node(``1``)``    ``root1.left ``=` `Node(``2``)``    ``root1.right ``=` `Node(``3``)``    ``root1.left.left ``=` `Node(``4``)``    ``root1.left.right ``=` `Node(``5``)` `    ``# Construct the second tree``    ``root2 ``=` `Node(``1``)``    ``root2.left ``=` `Node(``2``)``    ``root2.right ``=` `Node(``3``)``    ``root2.left.left ``=` `Node(``4``)``    ``root2.left.right ``=` `Node(``5``)` `    ``# Check if the trees are identical``    ``if` `isIdentical(root1, root2):``        ``print``(``"Both trees are identical"``)``    ``else``:``        ``print``(``"Both trees are not identical"``)`

## C#

 `// C# code to implement Iterative Postorder Traversal using``// two stacks``using` `System;``using` `System.Collections.Generic;` `// A binary tree node``class` `Node``{``    ``public` `int` `data;``    ``public` `Node left, right;``    ``public` `Node(``int` `x)``    ``{``        ``data = x;``        ``left = right = ``null``;``    ``}``}` `class` `IterativePostorderTraversal``{``    ``static` `bool` `IsIdentical(Node r1, Node r2)``    ``{``        ``Stack stack1 = ``new` `Stack();``        ``Stack stack2 = ``new` `Stack();` `        ``// Loop until both trees are completely traversed``        ``while` `(r1 != ``null` `|| stack1.Count > 0 || r2 != ``null` `|| stack2.Count > 0)``        ``{``            ``// Push all left nodes of the first tree in stack1``            ``while` `(r1 != ``null``)``            ``{``                ``stack1.Push(r1);``                ``r1 = r1.left;``            ``}``            ``// Push all left nodes of the second tree in stack2``            ``while` `(r2 != ``null``)``            ``{``                ``stack2.Push(r2);``                ``r2 = r2.left;``            ``}``            ``// If the sizes of both stacks are different, trees are not identical``            ``if` `(stack1.Count != stack2.Count)``                ``return` `false``;``            ``// Pop one node from each stack and compare their data``            ``r1 = stack1.Pop();``            ``r2 = stack2.Pop();``            ``if` `(r1.data != r2.data)``                ``return` `false``;``            ``// Move to the right of the popped nodes``            ``r1 = r1.right;``            ``r2 = r2.right;``        ``}``        ``// Both trees are identical``        ``return` `true``;``    ``}``// Driver code``    ``static` `void` `Main(``string``[] args)``    ``{``        ``// Construct the first tree``        ``Node root1 = ``new` `Node(1);``        ``root1.left = ``new` `Node(2);``        ``root1.right = ``new` `Node(3);``        ``root1.left.left = ``new` `Node(4);``        ``root1.left.right = ``new` `Node(5);` `        ``// Construct the second tree``        ``Node root2 = ``new` `Node(1);``        ``root2.left = ``new` `Node(2);``        ``root2.right = ``new` `Node(3);``        ``root2.left.left = ``new` `Node(4);``        ``root2.left.right = ``new` `Node(5);` `        ``// Check if the trees are identical``        ``if` `(IsIdentical(root1, root2))``            ``Console.WriteLine(``"Both trees are identical"``);``        ``else``            ``Console.WriteLine(``"Both trees are not identical"``);``    ``}``}`

## Javascript

 `// Define a binary tree node structure``class Node {``    ``constructor(data) {``        ``this``.data = data;``        ``this``.left = ``null``;``        ``this``.right = ``null``;``    ``}``}` `// Function to perform iterative postorder traversal and check if two binary trees are identical``function` `isIdentical(r1, r2) {``    ``const stack1 = [];``    ``const stack2 = [];` `    ``// Loop until both trees are completely traversed``    ``while` `(r1 || stack1.length > 0 || r2 || stack2.length > 0) {``        ``// Push all left nodes of the first tree into stack1``        ``while` `(r1) {``            ``stack1.push(r1);``            ``r1 = r1.left;``        ``}` `        ``// Push all left nodes of the second tree into stack2``        ``while` `(r2) {``            ``stack2.push(r2);``            ``r2 = r2.left;``        ``}` `        ``// If the sizes of both stacks are different, the trees are not identical``        ``if` `(stack1.length !== stack2.length)``            ``return` `false``;` `        ``// Pop one node from each stack and compare their data``        ``r1 = stack1.pop();``        ``r2 = stack2.pop();` `        ``if` `(r1.data !== r2.data)``            ``return` `false``;` `        ``// Move to the right of the popped nodes``        ``r1 = r1.right;``        ``r2 = r2.right;``    ``}` `    ``// Both trees are identical``    ``return` `true``;``}` `// Driver code``function` `main() {``    ``// Construct the first tree``    ``const root1 = ``new` `Node(1);``    ``root1.left = ``new` `Node(2);``    ``root1.right = ``new` `Node(3);``    ``root1.left.left = ``new` `Node(4);``    ``root1.left.right = ``new` `Node(5);` `    ``// Construct the second tree``    ``const root2 = ``new` `Node(1);``    ``root2.left = ``new` `Node(2);``    ``root2.right = ``new` `Node(3);``    ``root2.left.left = ``new` `Node(4);``    ``root2.left.right = ``new` `Node(5);` `    ``// Check if the trees are identical``    ``if` `(isIdentical(root1, root2))``        ``console.log(``"Both trees are identical"``);``    ``else``        ``console.log(``"Both trees are not identical"``);``}` `// Run the main function``main();`

Output
```Both trees are identical

```

Time Complexity: O(N) , The time complexity of the isIdentical function is O(n), where n is the total number of nodes in the trees. This is because we visit each node exactly once and perform a constant amount of work at each node.

Auxiliary Space: O(H) , The space complexity of the isIdentical function is O(h), where h is the maximum height of the two trees. This is because we use two stacks to keep track of the nodes in the two trees