Check if two nodes are cousins in a Binary Tree

Last Updated : 23 Jul, 2025

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

12-example

Output: True
Explanation: Node with the values 5 and 4 are on the same level with different parents.

Input: a = 4, b = 5

11-example

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

Try It Yourself
redirect icon

Table of Content

The idea is to check the level of both the given node values using depth first search. If their levels are same, then check if they are children of same or different nodes. If they have same parent, then return false. else, return true.

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

// Recursive function to check if two Nodes are siblings
bool isSibling(Node* root, int a, int b) {
    
    // Base case
    if (root == NULL)
        return false;

    if (root->left != nullptr && root->right != nullptr &&
        root->left->data == a && root->right->data == b)
        return true;
        
    if (root->left != nullptr && root->right != nullptr &&
        root->left->data == b && root->right->data == a)
        return true;
        
    return isSibling(root->left, a, b) ||
            isSibling(root->right, a,b);
}

// Recursive function to find level of Node with data = value in a
// binary tree
int level(Node* root, int value, int lev) {
    
    // base cases
    if (root == NULL)
        return 0;
    if (root->data == value)
        return lev;

    // Return level if Node is present in left subtree
    int l = level(root->left, value, lev + 1);
    if (l != 0)
        return l;

    // Else search in right subtree
    return level(root->right, value, lev + 1);
}

// Returns true if a and b are cousins, otherwise false
bool isCousins(Node* root, int a, int b) {
    
    // 1. The two Nodes should be on the same level in the
    // binary tree.
    // 2. The two Nodes should not be siblings (means that
    // they should
    // not have the same parent Node).
    
    if (a == b) 
        return false;
    
    int aLevel = level(root, a, 1);
    int bLevel = level(root, b, 1);
    
    // if a or b does not exists in the tree
    if (aLevel == 0 || bLevel == 0) 
        return false;
        
    if (aLevel == bLevel && !isSibling(root, a, b))
        return true;
    else
        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;
}
C 
// C program to 
// check if two Nodes are Cousins
#include <stdio.h>
#include <stdlib.h>

struct Node {
    int data;
    struct Node* left, *right;
};

// Recursive function to check if two Nodes are siblings
int isSibling(struct Node* root, int a, int b) {
    
    // Base case
    if (root == NULL)
        return 0;

    if (root->left != NULL && root->right != NULL &&
        root->left->data == a && root->right->data == b)
        return 1;
        
    if (root->left != NULL && root->right != NULL &&
        root->left->data == b && root->right->data == a)
        return 1;
        
    return isSibling(root->left, a, b) ||
           isSibling(root->right, a, b);
}

// Recursive function to find level of 
// Node with data = value in a binary tree
int level(struct Node* root, int value, int lev) {
    
    // base cases
    if (root == NULL)
        return 0;
    if (root->data == value)
        return lev;

    // Return level if Node is 
    // present in left subtree
    int l = level(root->left, value, lev + 1);
    if (l != 0)
        return l;

    // Else search in right subtree
    return level(root->right, value, lev + 1);
}

// Returns true if a and b are cousins, otherwise false
int isCousins(struct Node* root, int a, int b) {
    
    // 1. The two Nodes should be on 
    // the same level in the binary tree.
    // 2. The two Nodes should not be siblings 
    // (means that they should not 
    // have the same parent Node).
    
    if (a == b) 
        return 0;
    
    int aLevel = level(root, a, 1);
    int bLevel = level(root, b, 1);
    
    // if a or b does not exist in the tree
    if (aLevel == 0 || bLevel == 0) 
        return 0;
        
    if (aLevel == bLevel && !isSibling(root, a, b))
        return 1;
    else
        return 0;
}

struct Node* createNode(int x) {
    struct Node* newNode = 
    (struct Node*)malloc(sizeof(struct Node));
    newNode->data = x;
    newNode->left = newNode->right = NULL;
    return newNode;
}

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

    return 0;
}
Java 
// Java program to 
// check if two Nodes are Cousins
class Node {
    int data;
    Node left, right;
    
    Node(int x) {
        data = x;
        left = right = null;
    }
}

class GfG {
    
    // Recursive function to check if 
    // two Nodes are siblings
    static boolean isSibling(Node root, int a, int b) {
        
        // Base case
        if (root == null)
            return false;

        if (root.left != null && root.right != null &&
            root.left.data == a && root.right.data == b)
            return true;
            
        if (root.left != null && root.right != null &&
            root.left.data == b && root.right.data == a)
            return true;
            
        return isSibling(root.left, a, b) ||
               isSibling(root.right, a, b);
    }

    // Recursive function to find level of Node with 
  	// data = value in a binary tree
    static int level(Node root, int value, int lev) {
        
        // base cases
        if (root == null)
            return 0;
        if (root.data == value)
            return lev;

        // Return level if Node is present in left subtree
        int l = level(root.left, value, lev + 1);
        if (l != 0)
            return l;

        // Else search in right subtree
        return level(root.right, value, lev + 1);
    }

    // Returns true if a and b are cousins, otherwise false
    static boolean isCousins(Node root, int a, int b) {
        
        // 1. The two Nodes should be on the same 
      	// level in the binary tree.
        // 2. The two Nodes should not be siblings 
      	//(means that they should not have 
      	// the same parent Node).
        
        if (a == b) 
            return false;
        
        int aLevel = level(root, a, 1);
        int bLevel = level(root, b, 1);
        
        // if a or b does not exist in the tree
        if (aLevel == 0 || bLevel == 0) 
            return false;
            
        return aLevel == bLevel && !isSibling(root, a, b);
    }

    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 in a binary tree are cousins

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

# Recursive function to check 
# if two Nodes are siblings
def isSibling(root, a, b):
    
    # Base case
    if root is None:
        return False

    if root.left is not None and root.right is not None and \
       root.left.data == a and root.right.data == b:
        return True
        
    if root.left is not None and root.right is not None and \
       root.left.data == b and root.right.data == a:
        return True
        
    return isSibling(root.left, a, b) or isSibling(root.right, a, b)

# Recursive function to find level of Node with 
# data = value in a binary tree
def level(root, value, lev):
    
    # base cases
    if root is None:
        return 0
    if root.data == value:
        return lev

    # Return level if Node is present in left subtree
    l = level(root.left, value, lev + 1)
    if l != 0:
        return l

    # Else search in right subtree
    return level(root.right, value, lev + 1)

# Returns true if a and b are cousins, otherwise false
def isCousins(root, a, b):
    
    # 1. The two Nodes should be on the same 
    # level in the binary tree.
    # 2. The two Nodes should not be siblings 
    # (means that they should not 
    # have the same parent Node).
    
    if a == b:
        return False
    
    aLevel = level(root, a, 1)
    bLevel = level(root, b, 1)
    
    # if a or b does not exist in the tree
    if aLevel == 0 or bLevel == 0:
        return False
        
    return aLevel == bLevel and not isSibling(root, a, b)

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, b = 4, 5
    
    if isCousins(root, a, b):
        print("True")
    else:
        print("False")
C# 
// C# program to 
// check if two Nodes are Cousins
using System;

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

class GfG {
    
    // Recursive function to check 
    // if two Nodes are siblings
    static bool IsSibling(Node root, int a, int b) {
        
        // Base case
        if (root == null)
            return false;

        if (root.left != null && root.right != null &&
            root.left.data == a && root.right.data == b)
            return true;
            
        if (root.left != null && root.right != null &&
            root.left.data == b && root.right.data == a)
            return true;
            
        return IsSibling(root.left, a, b) ||
               IsSibling(root.right, a, b);
    }

    // Recursive function to find level of 
    // Node with data = value in a binary tree
    static int Level(Node root, int value, int lev) {
        
        // base cases
        if (root == null)
            return 0;
        if (root.data == value)
            return lev;

        // Return level if Node is present in left subtree
        int l = Level(root.left, value, lev + 1);
        if (l != 0)
            return l;

        // Else search in right subtree
        return Level(root.right, value, lev + 1);
    }

    // Returns true if a and b are cousins, otherwise false
    static bool IsCousins(Node root, int a, int b) {
        
        // 1. The two Nodes should be on the 
        // same level in the binary tree.
        // 2. The two Nodes should not be 
        // siblings (means that they should 
        // not have the same parent Node).
        
        if (a == b) 
            return false;
        
        int aLevel = Level(root, a, 1);
        int bLevel = Level(root, b, 1);
        
        // if a or b does not exist in the tree
        if (aLevel == 0 || bLevel == 0) 
            return false;
            
        return aLevel == bLevel && !IsSibling(root, a, b);
    }

    static void 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)) {
            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 = this.right = null;
    }
}

// Recursive function to check if two Nodes are siblings
function isSibling(root, a, b) {
    
    // Base case
    if (root == null)
        return false;

    if (root.left != null && root.right != null &&
        root.left.data === a && root.right.data === b)
        return true;
        
    if (root.left != null && root.right != null &&
        root.left.data === b && root.right.data === a)
        return true;
        
    return isSibling(root.left, a, b) || 
           isSibling(root.right, a, b);
}

// Recursive function to find level of Node with 
// data = value in a binary tree
function level(root, value, lev) {
    
    // base cases
    if (root == null)
        return 0;
    if (root.data === value)
        return lev;

    // Return level if Node is present in left subtree
    let l = level(root.left, value, lev + 1);
    if (l !== 0)
        return l;

    // Else search in right subtree
    return level(root.right, value, lev + 1);
}

// Returns true if a and b are cousins, otherwise false
function isCousins(root, a, b) {
    
    // 1. The two Nodes should be on the same level
    // in the binary tree.
    // 2. The two Nodes should not be siblings 
    // (means that they should not have the same parent Node).
    
    if (a === b) 
        return false;
    
    let aLevel = level(root, a, 1);
    let bLevel = level(root, b, 1);
    
    // if a or b does not exist in the tree
    if (aLevel === 0 || bLevel === 0)
        return false;
        
    return aLevel === bLevel && !isSibling(root, a, b);
}

// create hard coded tree
//       1
//     /   \ 
//    2     3
//   /       \
//  5         4 
let 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);

let 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 complexity: O(h), where h is the height of the tree.

In a depth-first search (DFS) approach to check if two nodes are cousins, we traverse the tree three times, resulting in a time complexity O(3n).

Using Breadth-First Search :

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. Please Refer to Check if two nodes are cousins in a Binary Tree using BFS for implementation.

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).

Comment

Explore