# Check if two Binary trees are identical after exactly K changes

Last Updated : 13 Dec, 2022

Given two binary trees T1 and T2 and integer K, the task is to check whether both trees are identical or not after making exactly K changes in the first tree. In each change, one tree element can be converted into any other integer.

Examples:

Input: K = 1
T1 =  1         T2  =      1
/   \                   /   \
2     4               2      3
Output: Yes
Explanation: Change the node with value 4 to value 3

Input: K = 5
T1   =    1                  T2  =   1
/       \                     /       \
2            5                3           5
/   \         /   \            /   \       /    \
7     9     10    11      7      6   10     21

Output: Yes
Explanation: In the above two tree there are 3 node value which are different in first tree i.e, 2, 9, 11.
Hence we make atleast 3 changes to convert them to 3, 6, 21 respectively to make tree identical.
After 3 changes left K = 5 – 3 = 2 changes.
Utilize these two changes by converting any node to any random one then convert back to original one.
In this way we have exactly K = 5 changes.

Approach: The problem is solved using an iterative approach using a stack.

• We check all the respective nodes of both the trees one by one with the help of iterative inorder traversal.
• If we found that the respective data parts of both the trees are not matching then we simply increment the count.
• If the structure of both the trees is different, return false.
• At the end we check if our count is less than K and (k-count) is even or not if so then return true else return false.

Below is the implementation of the above approach.

## C++

 `// C++ code to implement the above approach`   `#include ` `using` `namespace` `std;`   `// A binary tree node has data,` `// pointer to left child` `// and a pointer to right child` `class` `node {` `public``:` `    ``int` `data;` `    ``node* left;` `    ``node* right;` `};`   `// Function to create new node.` `node* newNode(``int` `data)` `{` `    ``node* Node = ``new` `node();` `    ``Node->data = data;` `    ``Node->left = NULL;` `    ``Node->right = NULL;`   `    ``return` `(Node);` `}`   `// Given two trees, return` `// true if they are` `// convertible to identical` `bool` `checkIdentical(node* p, node* q, ``int` `k)` `{` `    ``stack st1, st2;` `    ``int` `count = 0;`   `    ``while` `(p || !st1.empty() && q || !st2.empty()) {`   `        ``// If p are q are not null` `        ``// push in stack` `        ``if` `(p && q) {` `            ``st1.push(p);` `            ``st2.push(q);`   `            ``// Send p and q to its left child` `            ``p = p->left;` `            ``q = q->left;` `        ``}`   `        ``// when one of them is null means` `        ``// they have different` `        ``// structure return false` `        ``else` `if` `(p && !q || !p && q)` `            ``return` `0;`   `        ``// If p and q are null` `        ``// pop node from stack` `        ``else` `{` `            ``p = st1.top();` `            ``q = st2.top();`   `            ``st1.pop();` `            ``st2.pop();`   `            ``// If data not match increment count` `            ``if` `(p->data != q->data)` `                ``count++;`   `            ``// Send p and q to its right child` `            ``p = p->right;` `            ``q = q->right;` `        ``}` `    ``}`   `    ``if` `(count <= k && (k - count) % 2 == 0)` `        ``return` `1;` `    ``else` `        ``return` `0;` `}`   `// Driver code` `int` `main()` `{` `    ``/*    1           1` `        ``/   \       /   \` `       ``2     4     2     3` `    ``*/`   `    ``node* root1 = newNode(1);` `    ``root1->left = newNode(2);` `    ``root1->right = newNode(4);`   `    ``node* root2 = newNode(1);` `    ``root2->left = newNode(2);` `    ``root2->right = newNode(3);`   `    ``int` `K = 1;` `    ``if` `(checkIdentical(root1, root2, K))` `        ``cout << ``"Yes"``;` `    ``else` `        ``cout << ``"No"``;`   `    ``return` `0;` `}`

## Java

 `// Java code to implement the above approach`     `import` `java.util.*;`   `class` `GFG{`   `// A binary tree node has data,` `// pointer to left child` `// and a pointer to right child` `static` `class` `node {` `    ``int` `data;` `    ``node left;` `    ``node right;` `};`   `// Function to create new node.` `static` `node newNode(``int` `data)` `{` `    ``node Node = ``new` `node();` `    ``Node.data = data;` `    ``Node.left = ``null``;` `    ``Node.right = ``null``;`   `    ``return` `(Node);` `}`   `// Given two trees, return` `// true if they are` `// convertible to identical` `static` `boolean` `checkIdentical(node p, node q, ``int` `k)` `{` `    ``Stack st1 = ``new` `Stack<>();` `    ``Stack st2 = ``new` `Stack<>();` `    ``int` `count = ``0``;`   `    ``while` `(p!=``null` `|| (st1.isEmpty()) && q!=``null` `|| !st2.isEmpty()) {`   `        ``// If p are q are not null` `        ``// push in stack` `        ``if` `(p!=``null` `&& q!=``null``) {` `            ``st1.add(p);` `            ``st2.add(q);`   `            ``// Send p and q to its left child` `            ``p = p.left;` `            ``q = q.left;` `        ``}`   `        ``// when one of them is null means` `        ``// they have different` `        ``// structure return false` `        ``else` `if` `(p!=``null` `&& q==``null` `|| p==``null` `&& q!=``null``)` `        ``return` `false``;`   `        ``// If p and q are null` `        ``// pop node from stack` `        ``else` `{` `            ``p = st1.peek();` `            ``q = st2.peek();`   `            ``st1.pop();` `            ``st2.pop();`   `            ``// If data not match increment count` `            ``if` `(p.data != q.data)` `                ``count++;`   `            ``// Send p and q to its right child` `            ``p = p.right;` `            ``q = q.right;` `        ``}` `    ``}`   `    ``if` `(count <= k && (k - count) % ``2` `== ``0``)` `        ``return` `true``;` `    ``else` `    ``return` `false``;` `}`   `// Driver code` `public` `static` `void` `main(String[] args)` `{` `    ``/*    1           1` `        ``/   \       /   \` `       ``2     4     2     3` `    ``*/`   `    ``node root1 = newNode(``1``);` `    ``root1.left = newNode(``2``);` `    ``root1.right = newNode(``4``);`   `    ``node root2 = newNode(``1``);` `    ``root2.left = newNode(``2``);` `    ``root2.right = newNode(``3``);`   `    ``int` `K = ``1``;` `    ``if` `(checkIdentical(root1, root2, K))` `        ``System.out.print(``"Yes"``);` `    ``else` `        ``System.out.print(``"No"``);`   `}` `}`   `// This code contributed by shikhasingrajput`

## Python3

 `# Python code for the above approach`   `## A binary tree node has data,` `## pointer to left child` `## and a pointer to right child` `class` `node:` `    ``def` `__init__(``self``, d):` `        ``self``.data ``=` `d` `        ``self``.left ``=` `None` `        ``self``.right ``=` `None` `            `  `## Function to create new node.` `def` `newNode(data):` `    ``Node ``=` `node(data);` `    ``Node.left ``=` `None``;` `    ``Node.right ``=` `None``;`   `    ``return` `Node`   `## Given two trees, return` `## true if they are` `## convertible to identical` `def` `checkIdentical(p, q, k):` `    ``st1 ``=` `[]` `    ``st2 ``=` `[]` `    ``count ``=` `0`   `    ``while` `(p ``or` `(``len``(st1) > ``0``) ``and` `q ``or` `(``len``(st2) > ``0``)):`   `        ``## If p are q are not null` `        ``## push in stack` `        ``if` `(p ``and` `q):` `            ``st1.append(p)` `            ``st2.append(q)`   `            ``## Send p and q to its left child` `            ``p ``=` `p.left` `            ``q ``=` `q.left`   `        ``## when one of them is null means` `        ``## they have different` `        ``## structure return false` `        ``elif` `(p ``and` `(``not` `q) ``or` `(``not` `p) ``and` `q):` `            ``return` `0`   `        ``## If p and q are null` `        ``## pop node from stack` `        ``else``:` `            ``p ``=` `st1.pop()` `            ``st1.append(p)` `            ``q ``=` `st2.pop()` `            ``st2.append(q)`   `            ``st1.pop()` `            ``st2.pop()`   `            ``## If data not match increment count` `            ``if` `(p.data !``=` `q.data):` `                ``count``+``=``1`   `            ``## Send p and q to its right child` `            ``p ``=` `p.right` `            ``q ``=` `q.right`   `    ``if` `(count <``=` `k ``and` `(k ``-` `count) ``%` `2` `=``=` `0``):` `        ``return` `1` `    ``else``:` `        ``return` `0`     `# Driver Code` `if` `__name__``=``=``'__main__'``:`   `    ``##   1       1` `    ``##    / \      / \` `    ``##  2 4     2  3`   `    ``root1 ``=` `newNode(``1``);` `    ``root1.left ``=` `newNode(``2``);` `    ``root1.right ``=` `newNode(``4``);`   `    ``root2 ``=` `newNode(``1``);` `    ``root2.left ``=` `newNode(``2``);` `    ``root2.right ``=` `newNode(``3``);`   `    ``K ``=` `1``;` `    ``if` `(checkIdentical(root1, root2, K)):` `        ``print``(``"Yes"``)` `    ``else``:` `        ``print``(``"No"``)`   `        ``# This code is contributed by subhamgoyal2014.`

## C#

 `// C# code to implement the above approach` `using` `System;` `using` `System.Collections.Generic;`   `public` `class` `GFG{`   `  ``// A binary tree node has data,` `  ``// pointer to left child` `  ``// and a pointer to right child` `  ``public`     `    ``class` `node {` `      ``public` `int` `data;` `      ``public` `node left;` `      ``public` `node right;` `    ``};`   `  ``// Function to create new node.` `  ``static` `node newNode(``int` `data)` `  ``{` `    ``node Node = ``new` `node();` `    ``Node.data = data;` `    ``Node.left = ``null``;` `    ``Node.right = ``null``;`   `    ``return` `(Node);` `  ``}`   `  ``// Given two trees, return` `  ``// true if they are` `  ``// convertible to identical` `  ``static` `bool` `checkIdentical(node p, node q, ``int` `k)` `  ``{` `    ``Stack st1 = ``new` `Stack();` `    ``Stack st2 = ``new` `Stack();` `    ``int` `count = 0;`   `    ``while` `(p!=``null` `|| (st1.Count!=0) && q!=``null` `|| st2.Count!=0) {`   `      ``// If p are q are not null` `      ``// push in stack` `      ``if` `(p!=``null` `&& q!=``null``) {` `        ``st1.Push(p);` `        ``st2.Push(q);`   `        ``// Send p and q to its left child` `        ``p = p.left;` `        ``q = q.left;` `      ``}`   `      ``// when one of them is null means` `      ``// they have different` `      ``// structure return false` `      ``else` `if` `(p!=``null` `&& q==``null` `|| p==``null` `&& q!=``null``)` `        ``return` `false``;`   `      ``// If p and q are null` `      ``// pop node from stack` `      ``else` `{` `        ``p = st1.Peek();` `        ``q = st2.Peek();`   `        ``st1.Pop();` `        ``st2.Pop();`   `        ``// If data not match increment count` `        ``if` `(p.data != q.data)` `          ``count++;`   `        ``// Send p and q to its right child` `        ``p = p.right;` `        ``q = q.right;` `      ``}` `    ``}`   `    ``if` `(count <= k && (k - count) % 2 == 0)` `      ``return` `true``;` `    ``else` `      ``return` `false``;` `  ``}`   `  ``// Driver code` `  ``public` `static` `void` `Main(String[] args)` `  ``{` `    ``/*    1           1` `        ``/   \       /   \` `       ``2     4     2     3` `    ``*/`   `    ``node root1 = newNode(1);` `    ``root1.left = newNode(2);` `    ``root1.right = newNode(4);`   `    ``node root2 = newNode(1);` `    ``root2.left = newNode(2);` `    ``root2.right = newNode(3);`   `    ``int` `K = 1;` `    ``if` `(checkIdentical(root1, root2, K))` `      ``Console.Write(``"Yes"``);` `    ``else` `      ``Console.Write(``"No"``);`   `  ``}` `}`   `// This code contributed by shikhasingrajput`

## Javascript

 `// JavaScript code to implement the above approach`   `class Node {` `    ``constructor(data) {` `        ``this``.data = data;` `        ``this``.left = ``null``;` `        ``this``.right = ``null``;` `    ``}` `}`   `let root1, root2;` `// Given two trees, return` `// true if they are` `// convertible to identical` `function` `checkIdentical(p, q, k) {` `    ``let st1 = [];` `    ``let st2 = [];` `    ``let count = 0;`   `    ``while` `(p || st1.length != 0 && q || st2.length !== 0) {` `        ``// If p are q are not null` `        ``// push in stack` `        ``if` `(p && q) {` `            ``st1.push(p);` `            ``st2.push(q);`   `            ``// Send p and q to its left child` `            ``p = p.left;` `            ``q = q.left;` `        ``}`   `        ``// when one of them is null means` `        ``// they have different` `        ``// structure return false` `        ``else` `if` `(p && !q || !p && q) ``return` `false``;`   `        ``// If p and q are null` `        ``// pop node from stack` `        ``else` `{` `            ``p = st1[0];` `            ``q = st2[0];` `            ``st1.shift();` `            ``st2.shift();`   `            ``// If data not match increment count` `            ``if` `(p.data !== q.data) count++;`   `            ``// Send p and q to its right child` `            ``p = p.right;` `            ``q = q.right;` `        ``}` `    ``}`   `    ``if` `(count <= k && (k - count) % 2 === 0) ``return` `true``;` `    ``else` `return` `false``;` `}`   `// Driver code` `root1 = ``new` `Node(1);` `root1.left = ``new` `Node(2);` `root1.right = ``new` `Node(4);`   `root2 = ``new` `Node(1);` `root2.left = ``new` `Node(2);` `root2.right = ``new` `Node(3);`   `let k = 1;` `if` `(checkIdentical(root1, root2, k)) console.log(``"Yes"``);` `else` `console.log(``"No"``);`   `// This code is contributed by adityamaharshi21`

Output

`Yes`

Time Complexity: O(N)
Auxiliary Space: O(N)

Share your thoughts in the comments