Dado un árbol binario donde cada Node tiene un valor de 0 o 1, la tarea es convertir el árbol binario dado en un árbol XOR, es decir, un árbol tal que el valor de cada Node sea el XOR lógico entre sus hijos.
Nota : los Nodes hoja y los Nodes con un hijo no se consideran porque no tienen ambos hijos.
Ejemplos:
Entrada:
1
/ \
1 0
/ \ / \
0 1 0 1
Salida:
0
/ \
1 1
/ \ / \
0 1 0 1
Explicación: Cada valor de Node es el XOR lógico de sus hijos.
Por ejemplo, el Node más a la derecha en el segundo nivel es el XOR lógico de sus hijos. es decir, 0 ^ 1 = 1Entrada:
1
/ \
0 0
/ \ /
1 0 1
Salida:
1
/ \
1 0
/ \ /
1 0 1
Explicación: Cada Node tiene el mismo valor que el XOR lógico de sus hijos.
Por ejemplo, el Node más a la izquierda en el segundo nivel es el Xor lógico de sus hijos. es decir, 1 ^ 0 = 1.
El hijo más a la derecha del segundo nivel tiene un valor sin cambios porque solo tiene un hijo.
Planteamiento: El problema se puede resolver a partir de la siguiente idea:
La idea es realizar un recorrido posterior al orden del árbol porque en el recorrido posterior al orden se visitan ambos hijos antes que el Node raíz. Durante el recorrido, siga realizando el XOR de los hijos y cambie el valor del Node actual según eso.
Siga los pasos para resolver el problema:
- Para cada Node, compruebe recursivamente los hijos de los Nodes.
- Si el Node tiene solo un hijo o ningún hijo, no haga nada.
- De lo contrario, si el Node tiene ambos hijos, simplemente actualice los datos del Node con el XOR lógico de sus hijos.
A continuación se muestra la implementación del enfoque anterior:
C++
// C++ program to convert a BT to XOR tree
#include <bits/stdc++.h>
using namespace std;
// Struct node of binary tree
struct Node {
int data;
Node *left, *right;
};
// Function to create a new node
Node* newNode(int key)
{
Node* node = new Node;
node->data = key;
node->left = node->right = NULL;
return node;
}
// Utility function that converts
// BT to XOR tree which holds
// logical XOR property.
void convertTree(Node* root)
{
// Base case
if (root == NULL)
return;
// Recursion for left subtree
convertTree(root->left);
// Recursion for right subtree
convertTree(root->right);
// If the node has both childrens
// then update node's data as
// Logical Xor between childrens.
if (root->left != NULL
&& root->right != NULL)
root->data = root->left->data
^ root->right->data;
}
// Function to print
void printInorder(Node* root)
{
if (root == NULL)
return;
// Recursion for left subtree
printInorder(root->left);
// Print the data
cout << root->data << " ";
// Now recursion for right subtree
printInorder(root->right);
}
// Driver code
int main()
{
// Create a binary tree
Node* root = newNode(1);
root->left = newNode(1);
root->right = newNode(0);
root->left->left = newNode(0);
root->left->right = newNode(1);
root->right->left = newNode(0);
root->right->right = newNode(1);
cout << "Before conversion: ";
printInorder(root);
// Function to convert the tree
convertTree(root);
cout << "\nAfter conversion: ";
printInorder(root);
return 0;
}
Java
// JAVA program to convert a BT to XOR tree
import java.util.*;
class GFG
{
// Struct node of binary tree
public static class Node {
int data;
Node left, right;
}
// Function to create a new node
public static Node newNode(int key)
{
Node node = new Node();
node.data = key;
node.left = node.right = null;
return node;
}
// Utility function that converts
// BT to XOR tree which holds
// logical XOR property.
public static void convertTree(Node root)
{
// Base case
if (root == null)
return;
// Recursion for left subtree
convertTree(root.left);
// Recursion for right subtree
convertTree(root.right);
// If the node has both childrens
// then update node's data as
// Logical Xor between childrens.
if (root.left != null && root.right != null)
root.data = root.left.data ^ root.right.data;
}
// Function to print
public static void printInorder(Node root)
{
if (root == null)
return;
// Recursion for left subtree
printInorder(root.left);
// Print the data
System.out.print(root.data + " ");
// Now recursion for right subtree
printInorder(root.right);
}
// Driver code
public static void main(String[] args)
{
// Create a binary tree
Node root = newNode(1);
root.left = newNode(1);
root.right = newNode(0);
root.left.left = newNode(0);
root.left.right = newNode(1);
root.right.left = newNode(0);
root.right.right = newNode(1);
System.out.print("Before conversion: ");
printInorder(root);
// Function to convert the tree
convertTree(root);
System.out.print("\nAfter conversion: ");
printInorder(root);
}
}
// This code is contributed by Taranpreet
Python3
# Python program for the above approach
# Struct node of binary tree
class Node:
def __init__(self,key):
self.data = key
self.left = None
self.right = None
# Utility function that converts
# BT to XOR tree which holds
# logical XOR property.
def convertTree(root):
# Base case
if (root == None):
return
# Recursion for left subtree
convertTree(root.left)
# Recursion for right subtree
convertTree(root.right)
# If the node has both childrens
# then update node's data as
# Logical Xor between childrens.
if (root.left != None and root.right != None):
root.data = root.left.data ^ root.right.data
# Function to print
def printInorder(root):
if (root == None):
return
# Recursion for left subtree
printInorder(root.left)
# Print the data
print(root.data ,end = " ")
# Now recursion for right subtree
printInorder(root.right)
# Driver code
# Create a binary tree
root = Node(1)
root.left = Node(1)
root.right = Node(0)
root.left.left = Node(0)
root.left.right = Node(1)
root.right.left = Node(0)
root.right.right = Node(1)
print("Before conversion:",end=" ")
printInorder(root)
# Function to convert the tree
convertTree(root)
print()
print("After conversion:",end=" ")
printInorder(root)
# This code is contributed by shinjanpatra
C#
using System;
// C# program to convert a BT to XOR tree
public class GFG
{
// Struct node of binary tree
public class Node {
public int data;
public Node left, right;
}
// Function to create a new node
public static Node newNode(int key)
{
Node node = new Node();
node.data = key;
node.left = node.right = null;
return node;
}
// Utility function that converts
// BT to XOR tree which holds
// logical XOR property.
public static void convertTree(Node root)
{
// Base case
if (root == null)
return;
// Recursion for left subtree
convertTree(root.left);
// Recursion for right subtree
convertTree(root.right);
// If the node has both childrens
// then update node's data as
// Logical Xor between childrens.
if (root.left != null && root.right != null)
root.data = root.left.data ^ root.right.data;
}
// Function to print
public static void printInorder(Node root)
{
if (root == null)
return;
// Recursion for left subtree
printInorder(root.left);
// Print the data
Console.Write(root.data + " ");
// Now recursion for right subtree
printInorder(root.right);
}
// Driver code
public static void Main(string[] args)
{
// Create a binary tree
Node root = newNode(1);
root.left = newNode(1);
root.right = newNode(0);
root.left.left = newNode(0);
root.left.right = newNode(1);
root.right.left = newNode(0);
root.right.right = newNode(1);
Console.Write("Before conversion: ");
printInorder(root);
// Function to convert the tree
convertTree(root);
Console.Write("\nAfter conversion: ");
printInorder(root);
}
}
// This code is contributed by jana_sayantan.
Javascript
<script>
// JavaScript code for the above approach
// Struct node of binary tree
class Node {
constructor(key) {
this.data = key;
this.left = null;
this.right = null;
}
};
// Utility function that converts
// BT to XOR tree which holds
// logical XOR property.
function convertTree(root) {
// Base case
if (root == null)
return;
// Recursion for left subtree
convertTree(root.left);
// Recursion for right subtree
convertTree(root.right);
// If the node has both childrens
// then update node's data as
// Logical Xor between childrens.
if (root.left != null
&& root.right != null)
root.data = root.left.data
^ root.right.data;
}
// Function to print
function printInorder(root) {
if (root == null)
return;
// Recursion for left subtree
printInorder(root.left);
// Print the data
document.write(root.data + " ");
// Now recursion for right subtree
printInorder(root.right);
}
// Driver code
// Create a binary tree
let root = new Node(1);
root.left = new Node(1);
root.right = new Node(0);
root.left.left = new Node(0);
root.left.right = new Node(1);
root.right.left = new Node(0);
root.right.right = new Node(1);
document.write("Before conversion: ");
printInorder(root);
// Function to convert the tree
convertTree(root);
document.write('<br>' + "After conversion: ");
printInorder(root);
// This code is contributed by Potta Lokesh
</script>
Producción
Before conversion: 0 1 1 1 0 0 1 After conversion: 0 1 1 0 0 1 1
Tiempo Complejidad : O(N)
Espacio Auxiliar : O(N)
Publicación traducida automáticamente
Artículo escrito por upendra200223 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA