Skip to content
Related Articles

Related Articles

Improve Article

Print all the root-to-leaf paths of a Binary Tree whose XOR is non-zero

  • Difficulty Level : Easy
  • Last Updated : 05 Jul, 2021

Given a Binary Tree, the task is to print all root-to-leaf 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++




// 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;
}

Java




// 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

Python3




# 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

C#




// 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

Javascript




<script>
 
    // JavaScript program to Print all the Paths of a
    // Binary Tree whose XOR gives a non-zero value
     
    // A Tree node
    class Node
    {
       constructor(key) {
           this.left = null;
           this.right = null;
           this.key = key;
        }
    }
     
    // Function to create a new node
    function newNode(key)
    {
        let temp = new Node(key);
        return (temp);
    }
 
    // Function to check whether Path
    // is has non-zero xor value or not
    function PathXor(path)
    {
        let ans = 0;
 
        // Iterating through the array
        // to find the xor value
        for (let x = 0; x < path.length; x++)
        {
            ans ^= path[x];
        }
        if(ans != 0)
        {
            return true;
        }
        else{
            return false;
        }
    }
 
    // Function to print a path
    function printPaths(path)
    {
        for (let x = 0; x < path.length; x++)
        {
            document.write(path[x] + " ");
        }
        document.write("</br>");
    }
 
    // Function to find the paths of
    // binary tree having non-zero xor value
    function findPaths(root, path)
    {
        // Base case
        if (root == null)
            return;
 
        // Store the value in path vector
        path.push(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();
    }
 
    // Function to find the paths
    // having non-zero xor value
    function printpaths(node)
    {
        let path = [];
        findPaths(node, path);
    }
     
    /*        10
            /    \
          10      3
                /   \
              10     3
            /   \   /   \
            7    3 42   13
                        /
                       7
    */
  
    // Create Binary Tree as shown
    let 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);
             
</script>
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.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.




My Personal Notes arrow_drop_up
Recommended Articles
Page :