Skip to content
Related Articles

Related Articles

Print all the Paths of a Binary Tree whose XOR is non-zero
  • Difficulty Level : Easy
  • Last Updated : 26 Nov, 2020

Given a Binary Tree, the task is to print all the paths of this tree whose xor value is non-zero.

Examples: 

Input: 
             10   
            /   \   
           10    3   
               /   \   
              10     3   
              / \   / \   
             7   3 42 13   
                      /   
                     7   
Output:
10 3 10 7 
10 3 3 42
Explanation: 
All the paths in the given binary tree are :
{10, 10} xor value of the path is 
    = 10 ^ 10 = 0
{10, 3, 10, 7} xor value of the path is 
    = 10 ^ 3 ^ 10 ^ 7 != 0
{10, 3, 3, 42} xor value of the path is 
    = 10 ^ 3 ^ 3 ^ 42 != 0
{10, 3, 10, 3} xor value of the path is 
    = 10 ^ 3 ^ 10 ^ 3 = 0
{10, 3, 3, 13, 7} xor value of the path is 
    = 10 ^ 3 ^ 3 ^ 13 ^ 7 = 0. 
Hence, {10, 3, 10, 7} and {10, 3, 3, 42} are 
the paths whose xor value is non-zero.

Input:
            5
           /  \ 
         21     77 
        /  \      \
       5   21     16 
             \    / 
              5  3             
Output :
5 21 5
5 77 16 3
Explanation: 
{5, 21, 5} and {5, 77, 16, 3} are the paths
whose xor value is non-zero.

Approach: 
To solve the problem mentioned above the main idea is to traverse the tree and check if the xor of all the elements in that path is zero or not.  

  • We need to traverse the tree recursively using Pre-Order Traversal.
  • For each node keep calculating the XOR of the path from root till the current node.
  • If the node is a leaf node that is left and the right child for the current nodes are NULL then we check if the xor value of the path is non-zero or not, if it is then we print the entire path.

Below is the implementation of the above approach: 

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ program to Print all the Paths of a
// Binary Tree whose XOR gives a non-zero value
 
#include <bits/stdc++.h>
using namespace std;
 
// A Tree node
struct Node {
    int key;
    struct Node *left, *right;
};
 
// Function to create a new node
Node* newNode(int key)
{
    Node* temp = new Node;
    temp->key = key;
    temp->left = temp->right = NULL;
    return (temp);
}
 
// Function to check whether Path
// is has non-zero xor value or not
bool PathXor(vector<int>& path)
{
 
    int ans = 0;
 
    // Iterating through the array
    // to find the xor value
    for (auto x : path) {
        ans ^= x;
    }
 
    return (ans != 0);
}
 
// Function to print a path
void printPaths(vector<int>& path)
{
    for (auto x : path) {
        cout << x << " ";
    }
 
    cout << endl;
}
 
// Function to find the paths of
// binary tree having non-zero xor value
void findPaths(struct Node* root,
               vector<int>& path)
{
    // Base case
    if (root == NULL)
        return;
 
    // Store the value in path vector
    path.push_back(root->key);
 
    // Recursively call for left sub tree
    findPaths(root->left, path);
 
    // Recursively call for right sub tree
    findPaths(root->right, path);
 
    // Condition to check, if leaf node
    if (root->left == NULL
        && root->right == NULL) {
 
        // Condition to check,
        // if path has non-zero xor or not
        if (PathXor(path)) {
 
            // Print the path
            printPaths(path);
        }
    }
 
    // Remove the last element
    // from the path vector
    path.pop_back();
}
 
// Function to find the paths
// having non-zero xor value
void printPaths(struct Node* node)
{
    vector<int> path;
 
    findPaths(node, path);
}
 
// Driver Code
int main()
{
    /*          10
            /    \
          10      3
                /   \
              10     3
            /   \   /   \
            7    3 42   13
                        /
                       7
    */
 
    // Create Binary Tree as shown
    Node* root = newNode(10);
    root->left = newNode(10);
    root->right = newNode(3);
 
    root->right->left = newNode(10);
    root->right->right = newNode(3);
 
    root->right->left->left = newNode(7);
    root->right->left->right = newNode(3);
    root->right->right->left = newNode(42);
    root->right->right->right = newNode(13);
    root->right->right->right->left = newNode(7);
 
    // Print non-zero XOR Paths
    printPaths(root);
 
    return 0;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java program to Print all the Paths of a
// Binary Tree whose XOR gives a non-zero value
import java.util.*;
class GFG{
 
// A Tree node
static class Node
{
    int key;
    Node left, right;
};
 
// Function to create a new node
static Node newNode(int key)
{
    Node temp = new Node();
    temp.key = key;
    temp.left = temp.right = null;
    return (temp);
}
 
// Function to check whether Path
// is has non-zero xor value or not
static boolean PathXor(Vector<Integer> path)
{
    int ans = 0;
 
    // Iterating through the array
    // to find the xor value
    for (int x : path)
    {
        ans ^= x;
    }
    return (ans != 0);
}
 
// Function to print a path
static void printPaths(Vector<Integer> path)
{
    for (int x : path)
    {
        System.out.print(x + " ");
    }
    System.out.println();
}
 
// Function to find the paths of
// binary tree having non-zero xor value
static void findPaths(Node root,
                      Vector<Integer> path)
{
    // Base case
    if (root == null)
        return;
 
    // Store the value in path vector
    path.add(root.key);
 
    // Recursively call for left sub tree
    findPaths(root.left, path);
 
    // Recursively call for right sub tree
    findPaths(root.right, path);
 
    // Condition to check, if leaf node
    if (root.left == null &&
        root.right == null)
    {
        // Condition to check,
        // if path has non-zero xor or not
        if (PathXor(path))
        {
            // Print the path
            printPaths(path);
        }
    }
 
    // Remove the last element
    // from the path vector
    path.remove(path.size() - 1);
}
 
// Function to find the paths
// having non-zero xor value
static void printPaths(Node node)
{
    Vector<Integer> path = new Vector<Integer>();
    findPaths(node, path);
}
 
// Driver Code
public static void main(String[] args)
{
    /*        10
            /    \
          10      3
                /   \
              10     3
            /   \   /   \
            7    3 42   13
                        /
                       7
    */
 
    // Create Binary Tree as shown
    Node root = newNode(10);
    root.left = newNode(10);
    root.right = newNode(3);
 
    root.right.left = newNode(10);
    root.right.right = newNode(3);
 
    root.right.left.left = newNode(7);
    root.right.left.right = newNode(3);
    root.right.right.left = newNode(42);
    root.right.right.right = newNode(13);
    root.right.right.right.left = newNode(7);
 
    // Print non-zero XOR Paths
    printPaths(root);
}
}
 
// This code is contributed by shikhasingrajput

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python3 program to print all
# the paths of a Binary Tree
# whose XOR gives a non-zero value
 
# A Tree node
class Node:
     
    def __init__(self, key):
         
        self.key = key
        self.left = None
        self.right = None
 
# Function to check whether Path
# is has non-zero xor value or not
def PathXor(path: list) -> bool:
 
    ans = 0
 
    # Iterating through the array
    # to find the xor value
    for x in path:
        ans ^= x
 
    return (ans != 0)
 
# Function to print a path
def printPathsList(path: list) -> None:
 
    for x in path:
        print(x, end = " ")
         
    print()
 
# Function to find the paths of
# binary tree having non-zero xor value
def findPaths(root: Node, path: list) -> None:
 
    # Base case
    if (root == None):
        return
 
    # Store the value in path vector
    path.append(root.key)
 
    # Recursively call for left sub tree
    findPaths(root.left, path)
 
    # Recursively call for right sub tree
    findPaths(root.right, path)
 
    # Condition to check, if leaf node
    if (root.left == None and
        root.right == None):
 
        # Condition to check, if path
        # has non-zero xor or not
        if (PathXor(path)):
 
            # Print the path
            printPathsList(path)
 
    # Remove the last element
    # from the path vector
    path.pop()
 
# Function to find the paths
# having non-zero xor value
def printPaths(node: Node) -> None:
 
    path = []
    newNode = node
 
    findPaths(newNode, path)
 
# Driver Code
if __name__ == "__main__":
     
    '''       10
            /    \
          10      3
                /   \
              10     3
            /   \   /   \
            7    3 42   13
                        /
                       7
    '''
 
    # Create Binary Tree as shown
    root = Node(10)
    root.left = Node(10)
    root.right = Node(3)
 
    root.right.left = Node(10)
    root.right.right = Node(3)
 
    root.right.left.left = Node(7)
    root.right.left.right = Node(3)
    root.right.right.left = Node(42)
    root.right.right.right = Node(13)
    root.right.right.right.left = Node(7)
 
    # Print non-zero XOR Paths
    printPaths(root)
 
# This code is contributed by sanjeev2552

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# program to Print all the Paths of a
// Binary Tree whose XOR gives a non-zero value
using System;
using System.Collections.Generic;
class GFG{
 
// A Tree node
class Node
{
    public int key;
    public Node left, right;
};
 
// Function to create a new node
static Node newNode(int key)
{
    Node temp = new Node();
    temp.key = key;
    temp.left = temp.right = null;
    return (temp);
}
 
// Function to check whether Path
// is has non-zero xor value or not
static bool PathXor(List<int> path)
{
    int ans = 0;
 
    // Iterating through the array
    // to find the xor value
    foreach (int x in path)
    {
        ans ^= x;
    }
    return (ans != 0);
}
 
// Function to print a path
static void printPaths(List<int> path)
{
    foreach (int x in path)
    {
        Console.Write(x + " ");
    }
    Console.WriteLine();
}
 
// Function to find the paths of
// binary tree having non-zero xor value
static void findPaths(Node root,
                      List<int> path)
{
    // Base case
    if (root == null)
        return;
 
    // Store the value in path vector
    path.Add(root.key);
 
    // Recursively call for left sub tree
    findPaths(root.left, path);
 
    // Recursively call for right sub tree
    findPaths(root.right, path);
 
    // Condition to check, if leaf node
    if (root.left == null &&
        root.right == null)
    {
        // Condition to check,
        // if path has non-zero xor or not
        if (PathXor(path))
        {
            // Print the path
            printPaths(path);
        }
    }
 
    // Remove the last element
    // from the path vector
    path.RemoveAt(path.Count - 1);
}
 
// Function to find the paths
// having non-zero xor value
static void printPaths(Node node)
{
    List<int> path = new List<int>();
    findPaths(node, path);
}
 
// Driver Code
public static void Main(String[] args)
{
    /*        10
            /    \
          10      3
                /   \
              10     3
            /   \   /   \
            7    3 42   13
                        /
                       7
    */
 
    // Create Binary Tree as shown
    Node root = newNode(10);
    root.left = newNode(10);
    root.right = newNode(3);
 
    root.right.left = newNode(10);
    root.right.right = newNode(3);
 
    root.right.left.left = newNode(7);
    root.right.left.right = newNode(3);
    root.right.right.left = newNode(42);
    root.right.right.right = newNode(13);
    root.right.right.right.left = newNode(7);
 
    // Print non-zero XOR Paths
    printPaths(root);
}
}
 
// This code is contributed by shikhasingrajput

chevron_right


Output: 

10 3 10 7 
10 3 3 42

 

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.




My Personal Notes arrow_drop_up
Recommended Articles
Page :