GeeksforGeeks App
Open App
Browser
Continue

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

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)

My Personal Notes arrow_drop_up