Check if two nodes are cousins in a Binary Tree using BFS

Given a binary tree (having distinct node values) root and two node values. The task is to check whether the two nodes with values a and b are cousins.

Note: Two nodes of a binary tree are cousins if they have the same depth with different parents.

Example:

Input: a = 5, b = 4

Output: True
Explanation: Node with the values 5 and 4 are on the same level with different parents.
Input: a = 4, b = 5

Output: False
Explanation: Node with the values 5 and 4 are on the same level with same parent.

Approach:

The idea is to use a queue to traverse the tree in a level-order manner. This allows us to explore all nodes at a given depth before moving deeper. If the two nodes are found at the same level and are not siblings, then we return true, indicating they are cousins. Otherwise, we return false, as this means they either do not share the same depth or are sibling.

Step-by-step implementation:

Initialize two boolean variables. Lets say aFound and bFound (initially set to false).
Push the root node into a queue and follow while queue is not empty:
- Calculate the size of the queue, say 's'. Pop 's' nodes in one iteration. This way, we will traverse the tree in level order.
- Pop the node. If the node has value equal to a, then set aFound=true. If its value is equal to b, set bFound=true. To check that a and b are siblings or not, check if the given node has two children nodes. If it has two children and they are equal to a and b or b and a, then return false. Otherwise, push the left and right child nodes into the queue.
- After popping 's' elements, check the values of aFound and bFound. If both of them are true, then it means that both these nodes were found at the same level, and return true. If one of them is true, then return false as their level is different. If both are false, then continue the steps.

Below is the implementation of the above approach:

C++

// C++ program to 
// check if two Nodes are Cousins
#include <bits/stdc++.h>
using namespace std;

class Node{
    public:
        int data;
        Node* left, *right;
        Node(int x) {
            data = x;
            left = right = nullptr;
        }
};

// Funtion to check if two nodes are cousins
bool isCousins(Node* root, int a, int b) {
    
    // base case
    if (root == nullptr) return false;
  
  	// return false if a and b are equal
    if (a == b) return false;
    
    queue<Node*> q;
    
    // Push the root node into queue
    q.push(root);
    
    // variables to check if a and b are found yet.
    bool aFound = false, bFound = false;
    
    while (!q.empty()) {
        int s = q.size();
        
        // To simulate level order traversal,
        // only traverse the first s nodes in
        // the queue.
        while (s--) {
            Node* curr = q.front();
            q.pop();
            
            if (curr->data == a) 
                aFound = true;
            if (curr->data == b) {
                bFound = true;
            }
            
            // if a and b are children to the same node, 
            // then return false.
            if (curr->left != nullptr && curr->right != nullptr &&
            ( (curr->left->data == a && curr->right->data == b) || 
              (curr->left->data == b && curr->right->data == a) ) )
                return false;
            
            // push left node into queue    
            if (curr->left != nullptr) 
                q.push(curr->left);
            
            // Push right node into queue.    
            if (curr->right != nullptr) 
                q.push(curr->right);
        }
        
        // After iteration of one level, following needs to 
        // be checked
        
        // if both a and b are found,
        // return true.
        if (aFound && bFound)
            return true;
        
        // if one of a or b is found,
        // return false.
        if (aFound || bFound)
            return false;
    }
    
    return false;
}

int main() {
    
    // create hard coded tree
    //       1
    //     /   \ 
    //    2     3
    //   /       \
    //  5         4 
    Node* root = new Node(1);
    root->left = new Node(2);
    root->right = new Node(3);
    root->left->left = new Node(4);
    root->right->right = new Node(5);
    
    int a = 4, b = 5;
    
    if (isCousins(root, a, b)) {
        cout << "True" << endl;
    }
    else {
        cout << "False" << endl;
    }

    return 0;
}

Java

// Java program to 
// check if two Nodes are Cousins
import java.util.LinkedList;
import java.util.Queue;

class Node {
    int data;
    Node left, right;
    
    Node(int x) {
        data = x;
        left = right = null;
    }
}

// Function to check if two nodes are cousins
class GfG {

    static boolean isCousins(Node root, int a, int b) {
        
        // base case
        if (root == null) return false;
        
        // return false if a and b are equal
        if (a == b) return false;
        
        Queue<Node> q = new LinkedList<>();
        
        // Push the root node into queue
        q.add(root);
        
        // variables to check if a and b are found yet.
        boolean aFound = false, bFound = false;
        
        while (!q.isEmpty()) {
            int s = q.size();
            
            // To simulate level order traversal,
            // only traverse the first s nodes in
            // the queue.
            for (int i = 0; i < s; i++) {
                Node curr = q.poll();
                
                if (curr.data == a) 
                    aFound = true;
                if (curr.data == b) {
                    bFound = true;
                }
                
                // if a and b are children to the same node, 
                // then return false.
                if (curr.left != null && curr.right != null &&
                ((curr.left.data == a && curr.right.data == b) || 
                 (curr.left.data == b && curr.right.data == a))) {
                    return false;
                }
                
                // push left node into queue    
                if (curr.left != null) 
                    q.add(curr.left);
                
                // Push right node into queue.    
                if (curr.right != null) 
                    q.add(curr.right);
            }
            
            // After iteration of one level, following needs to 
            // be checked
            
            // if both a and b are found,
            // return true.
            if (aFound && bFound)
                return true;
            
            // if one of a or b is found,
            // return false.
            if (aFound || bFound)
                return false;
        }
        
        return false;
    }

    public static void main(String[] args) {
        
        // create hard coded tree
        //       1
        //     /   \ 
        //    2     3
        //   /       \
        //  5         4 
        Node root = new Node(1);
        root.left = new Node(2);
        root.right = new Node(3);
        root.left.left = new Node(4);
        root.right.right = new Node(5);
        
        int a = 4, b = 5;
        
        if (isCousins(root, a, b)) {
            System.out.println("True");
        }
        else {
            System.out.println("False");
        }
    }
}

Python

# Python program to 
# check if two Nodes are Cousins
from collections import deque

class Node:
    def __init__(self, x):
        self.data = x
        self.left = None
        self.right = None

# Function to check if two nodes are cousins
def isCousins(root, a, b):
    
    # base case
    if not root:
        return False
        
    # return false if a and b are equal
    if a == b:
        return False
    
    queue = deque()
    
    # Push the root node into queue
    queue.append(root)
    
    # variables to check if a and b are found yet.
    aFound = False
    bFound = False
    
    while queue:
        s = len(queue)
        
        # To simulate level order traversal,
        # only traverse the first s nodes in
        # the queue.
        for _ in range(s):
            curr = queue.popleft()
            
            if curr.data == a: 
                aFound = True
            if curr.data == b:
                bFound = True
            
            # if a and b are children to the same node, 
            # then return False.
            if curr.left and curr.right and \
            ((curr.left.data == a and curr.right.data == b) or 
             (curr.left.data == b and curr.right.data == a)):
                return False
            
            # push left node into queue    
            if curr.left:
                queue.append(curr.left)
            
            # Push right node into queue.    
            if curr.right:
                queue.append(curr.right)
        
        # After iteration of one level, following needs to 
        # be checked
        
        # if both a and b are found,
        # return True.
        if aFound and bFound:
            return True
        
        # if one of a or b is found,
        # return False.
        if aFound or bFound:
            return False
    
    return False

if __name__ == "__main__":
    
    # create hard coded tree
    #       1
    #     /   \ 
    #    2     3
    #   /       \
    #  5         4 
    root = Node(1)
    root.left = Node(2)
    root.right = Node(3)
    root.left.left = Node(4)
    root.right.right = Node(5)
    
    a = 4
    b = 5
    
    if isCousins(root, a, b):
        print("True")
    else:
        print("False")

// C# program to 
// check if two Nodes are Cousins
using System;
using System.Collections.Generic;

class Node {
    public int data;
    public Node left, right;

    public Node(int x) {
        data = x;
        left = right = null;
    }
}

class GfG {
    
    // Function to check if two nodes are cousins
    static bool IsCousins(Node root, int a, int b) {
        
        // base case
        if (root == null) return false;
        
        // return false if a and b are equal
        if (a == b) return false;
        
        Queue<Node> q = new Queue<Node>();
        
        // Push the root node into queue
        q.Enqueue(root);
        
        // variables to check if a and b are found yet.
        bool aFound = false, bFound = false;
        
        while (q.Count > 0) {
            int s = q.Count;
            
            // To simulate level order traversal,
            // only traverse the first s nodes in
            // the queue.
            for (int i = 0; i < s; i++) {
                Node curr = q.Dequeue();
                
                if (curr.data == a) 
                    aFound = true;
                if (curr.data == b) {
                    bFound = true;
                }
                
                // if a and b are children to the same node, 
                // then return false.
                if (curr.left != null && curr.right != null &&
                ((curr.left.data == a && curr.right.data == b) || 
                 (curr.left.data == b && curr.right.data == a))) {
                    return false;
                }
                
                // push left node into queue    
                if (curr.left != null) 
                    q.Enqueue(curr.left);
                
                // Push right node into queue.    
                if (curr.right != null) 
                    q.Enqueue(curr.right);
            }
            
            // After iteration of one level, following needs to 
            // be checked
            
            // if both a and b are found,
            // return true.
            if (aFound && bFound)
                return true;
            
            // if one of a or b is found,
            // return false.
            if (aFound || bFound)
                return false;
        }
        
        return false;
    }

    static void Main(string[] args) {
        
        // create hard coded tree
        //       1
        //     /   \ 
        //    2     3
        //   /       \
        //  5         4 
        Node root = new Node(1);
        root.left = new Node(2);
        root.right = new Node(3);
        root.left.left = new Node(4);
        root.right.right = new Node(5);
        
        int a = 4, b = 5;
        
        if (IsCousins(root, a, b)) {
            Console.WriteLine("True");
        }
        else {
            Console.WriteLine("False");
        }
    }
}

JavaScript

// JavaScript program to 
// check if two Nodes are Cousins
class Node {
    constructor(x) {
        this.data = x;
        this.left = null;
        this.right = null;
    }
}

// Function to check if two nodes are cousins
function isCousins(root, a, b) {

    // base case
    if (!root) return false;
    
    // return false if a and b are equal
    if (a == b) return false;

    const queue = [];

    // Push the root node into queue
    queue.push(root);

    // variables to check if a and b are found yet.
    let aFound = false, bFound = false;

    while (queue.length > 0) {
        const size = queue.length;

        // To simulate level order traversal,
        // only traverse the first size nodes in
        // the queue.
        for (let i = 0; i < size; i++) {
            const curr = queue.shift();

            if (curr.data === a) 
                aFound = true;
            if (curr.data === b) {
                bFound = true;
            }

            // if a and b are children to the same node, 
            // then return false.
            if (curr.left !== null && curr.right !== null &&
            ((curr.left.data === a && curr.right.data === b) || 
             (curr.left.data === b && curr.right.data === a))) {
                return false;
            }

            // push left node into queue    
            if (curr.left !== null) 
                queue.push(curr.left);

            // Push right node into queue.    
            if (curr.right !== null) 
                queue.push(curr.right);
        }

        // After iteration of one level, following needs to 
        // be checked

        // if both a and b are found,
        // return true.
        if (aFound && bFound)
            return true;

        // if one of a or b is found,
        // return false.
        if (aFound || bFound)
            return false;
    }

    return false;
}

// create hard coded tree
//       1
//     /   \ 
//    2     3
//   /       \
//  5         4 
const root = new Node(1);
root.left = new Node(2);
root.right = new Node(3);
root.left.left = new Node(4);
root.right.right = new Node(5);

const a = 4, b = 5;

if (isCousins(root, a, b)) {
    console.log("True");
} else {
    console.log("False");
}

Output

True

Time Complexity O(n), where n are the number of nodes in binary tree.
Auxiliary Space: O(n), if the tree is completely unbalanced, the maximum size of the queue can grow to O(n).

Please Refer to Check if two nodes are cousins in a Binary Tree to solve using Depth First Search.

Check if two nodes are cousins in a Binary Tree using BFS

Explore