Find the Neighbours of a Node in a tree

Given a tree and a value of the node find out whether the node exists if exists, then find the neighbors of that node.

Examples:

Input: Consider the below tree as input and K = 4

Binary Tree

Output: 4 5 6 7

Input: Consider the below tree and K = 8

Binary Tree

Output: Node with Value 8 does not exist.

Approach: To solve the problem follow the below steps:

To check if given node exists or not:

• If the root pointer is nullptr, indicating an empty tree, return false because the node doesn’t exist.
• Check if the value of the current root node is equal to the targetValue. If they are equal, return true.
• If the targetValue is not found at the current node, make two recursive calls:
• Call nodeExists on the left subtree (root -> left).
• Call nodeExists on the right subtree (root -> right).

Find the neighoubours of a node using Level Order Traversal (Breadth First Search or BFS):

• Initializes two vectors ans to store nodes at each level during traversal and vec to store the neighbors of the target node.
• If the root is NULL, indicating an empty tree, the function returns an empty vector
• First performs a level-order traversal of the tree using a queue. It processes nodes level by level.
• Now traverse the ans vector and checks if the current node’s value matches the targetValue. If found, it stores the nodes at that level in vec.
• If neighbors are found, it returns vec containing the neighbors. If no neighbors are found, it returns an empty vector.

Below is the implementation of above approach:

C++

// C++ code for the above approach:
#include <bits/stdc++.h>
using namespace std;

class TreeNode {
public:
    int value;
    TreeNode* left;
    TreeNode* right;

    TreeNode(int val)
        : value(val)
        , left(nullptr)
        , right(nullptr)
    {
    }
};

// Check if a node with a specific value
// exists in a binary tree
bool nodeExists(TreeNode* root, int targetValue)
{

    // Node doesn't exist
    if (root == nullptr) {
        return false;
    }

    // Node exists
    if (root->value == targetValue) {
        return true;
    }

    // Recursive call
    return nodeExists(root->left, targetValue)
           || nodeExists(root->right, targetValue);
}

vector<int> findNodeNeighbors(TreeNode* root,
                              int targetValue)
{

    // Vector to store nodes at each level
    vector<vector<int> > ans;

    // Vector to store neighbours
    vector<int> vec;
    if (root == NULL) {
        return vec;
    }

    // To store the level of the node
    queue<TreeNode*> q;
    q.push(root);
    while (!q.empty()) {
        int size = q.size();

        // Vector to store nodes at the
        // current level
        vector<int> ds;
        for (int i = 0; i < size; i++) {
            TreeNode* temp = q.front();
            q.pop();
            ds.push_back(temp->value);

            // If temp->left exists push
            if (temp->left != NULL) {
                q.push(temp->left);
            }

            // If temp->right exists push
            if (temp->right != NULL) {
                q.push(temp->right);
            }
        }

        // Storing the nodes at current level
        ans.push_back(ds);
    }

    // Finding the neighbours using for loop
    for (auto it : ans) {
        if (find(it.begin(), it.end(), targetValue)
            != it.end()) {
            vec = it;

            // Return neighbors if found
            return vec;
        }
    }

    // Return an empty vector if not found
    return vec;
}

// Driver code
int main()
{

    // Declaring tree
    TreeNode* root = new TreeNode(1);
    root->left = new TreeNode(2);
    root->right = new TreeNode(3);
    root->left->left = new TreeNode(4);
    root->left->right = new TreeNode(5);
    root->right->left = new TreeNode(6);
    root->right->right = new TreeNode(7);

    // For storing the answer
    vector<int> ans;

    // Value to find
    int targetValue = 4;

    if (nodeExists(root, targetValue)) {

        // Exist
        cout << "Node with value " << targetValue
             << " exists." << endl;
        ans = findNodeNeighbors(root, targetValue);
    }
    else {

        // Does not exist
        cout << "Node with value " << targetValue
             << " does not exist." << endl;
    }

    // Printing the neighbours
    cout << "Neighbours are:\n";
    for (auto it : ans) {
        cout << it << " ";
    }

    // Deallocate memory
    delete root->left->left;
    delete root->left->right;
    delete root->left;
    delete root->right->left;
    delete root->right;
    delete root;

    return 0;
}

Java

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;

class TreeNode {
    public int value;
    public TreeNode left;
    public TreeNode right;

    public TreeNode(int val) {
        value = val;
        left = null;
        right = null;
    }
}

public class BinaryTree {
    // Check if a node with the target value exists in the binary tree
    public static boolean nodeExists(TreeNode root, int targetValue) {
        if (root == null) {
            return false;  // If the root is null, the node does not exist.
        }

        if (root.value == targetValue) {
            return true;  // If the current node's value matches the target, it exists.
        }

        // Recursively search in the left and right subtrees.
        return nodeExists(root.left, targetValue) || nodeExists(root.right, targetValue);
    }

    // Find neighbors of a node with the target value in the binary tree
    public static List<Integer> findNodeNeighbors(TreeNode root, int targetValue) {
        List<List<Integer>> ans = new ArrayList<>();  // List of lists to store levels of nodes
        List<Integer> vec = new ArrayList<>();  // List to store neighbors

        if (root == null) {
            return vec;  // If the root is null, there are no neighbors.
        }

        Queue<TreeNode> q = new LinkedList<>();
        q.add(root);

        while (!q.isEmpty()) {
            int size = q.size();
            List<Integer> ds = new ArrayList<>();  // List to store nodes at the current level

            for (int i = 0; i < size; i++) {
                TreeNode temp = q.poll();
                ds.add(temp.value);

                if (temp.left != null) {
                    q.add(temp.left);
                }

                if (temp.right != null) {
                    q.add(temp.right);
                }
            }

            ans.add(ds);  // Store the nodes at the current level in the answer list.
        }

        for (List<Integer> it : ans) {
            if (it.contains(targetValue)) {
                vec = it;  // If the target value is found in a level, set it as the neighbors.
                return vec;
            }
        }

        return vec;  // Return the list of neighbors.
    }

    public static void main(String[] args) {
        TreeNode root = new TreeNode(1);
        root.left = new TreeNode(2);
        root.right = new TreeNode(3);
        root.left.left = new TreeNode(4);
        root.left.right = new TreeNode(5);
        root.right.left = new TreeNode(6);
        root.right.right = new TreeNode(7);

        List<Integer> ans = new ArrayList<>();
        int targetValue = 4;

        if (nodeExists(root, targetValue)) {
            System.out.println("Node with value " + targetValue + " exists.");
            ans = findNodeNeighbors(root, targetValue);
        } else {
            System.out.println("Node with value " + targetValue + " does not exist.");
        }

        System.out.println("Neighbours are:");
        for (int it : ans) {
            System.out.print(it + " ");
        }
    }
}

Python3

from collections import deque

class TreeNode:
    def __init__(self, val):
        self.value = val
        self.left = None
        self.right = None

# Check if a node with the target value exists in the binary tree
def nodeExists(root, targetValue):
    if root is None:
        return False  # If the root is None, the node does not exist.

    if root.value == targetValue:
        return True  # If the current node's value matches the target, it exists.

    # Recursively search in the left and right subtrees.
    return nodeExists(root.left, targetValue) or nodeExists(root.right, targetValue)

# Find neighbors of a node with the target value in the binary tree
def findNodeNeighbors(root, targetValue):
    ans = []  # List of lists to store levels of nodes
    vec = []  # List to store neighbors

    if root is None:
        return vec  # If the root is None, there are no neighbors.

    q = deque()
    q.append(root)

    while q:
        size = len(q)
        ds = []  # List to store nodes at the current level

        for i in range(size):
            temp = q.popleft()
            ds.append(temp.value)

            if temp.left:
                q.append(temp.left)

            if temp.right:
                q.append(temp.right)

        ans.append(ds)  # Store the nodes at the current level in the answer list.

    for it in ans:
        if targetValue in it:
            vec = it  # If the target value is found in a level, set it as the neighbors.
            return vec

    return vec  # Return the list of neighbors.

if __name__ == "__main__":
    root = TreeNode(1)
    root.left = TreeNode(2)
    root.right = TreeNode(3)
    root.left.left = TreeNode(4)
    root.left.right = TreeNode(5)
    root.right.left = TreeNode(6)
    root.right.right = TreeNode(7)

    ans = []
    targetValue = 4

    if nodeExists(root, targetValue):
        print("Node with value", targetValue, "exists.")
        ans = findNodeNeighbors(root, targetValue)
    else:
        print("Node with value", targetValue, "does not exist.")

    print("Neighbours are:")
    for it in ans:
        print(it, end=" ")
#This code is contributed by chinmaya121221

C#

using System;
using System.Collections.Generic;
using System.Linq;

public class TreeNode
{
    public int value;
    public TreeNode left;
    public TreeNode right;

    public TreeNode(int val)
    {
        value = val;
        left = null;
        right = null;
    }
}

public class BinaryTree
{
    public static bool NodeExists(TreeNode root, int targetValue)
    {
        if (root == null)
            return false;

        if (root.value == targetValue)
            return true;

        return NodeExists(root.left, targetValue) || NodeExists(root.right, targetValue);
    }

    public static List<int> FindNodeNeighbors(TreeNode root, int targetValue)
    {
        var ans = new List<List<int>>();
        var vec = new List<int>();

        if (root == null)
            return vec;

        Queue<TreeNode> q = new Queue<TreeNode>();
        q.Enqueue(root);

        while (q.Count > 0)
        {
            int size = q.Count;
            List<int> ds = new List<int>();

            for (int i = 0; i < size; i++)
            {
                TreeNode temp = q.Dequeue();
                ds.Add(temp.value);

                if (temp.left != null)
                    q.Enqueue(temp.left);

                if (temp.right != null)
                    q.Enqueue(temp.right);
            }

            ans.Add(ds);
        }

        foreach (var it in ans)
        {
            if (it.Contains(targetValue))
            {
                vec = it;
                return vec;
            }
        }

        return vec;
    }

    public static void Main(string[] args)
    {
        TreeNode root = new TreeNode(1);
        root.left = new TreeNode(2);
        root.right = new TreeNode(3);
        root.left.left = new TreeNode(4);
        root.left.right = new TreeNode(5);
        root.right.left = new TreeNode(6);
        root.right.right = new TreeNode(7);

        List<int> ans = new List<int>();
        int targetValue = 4;

        if (NodeExists(root, targetValue))
        {
            Console.WriteLine($"Node with value {targetValue} exists.");
            ans = FindNodeNeighbors(root, targetValue);
        }
        else
        {
            Console.WriteLine($"Node with value {targetValue} does not exist.");
        }

        Console.WriteLine("Neighbours are:");
        foreach (var item in ans)
        {
            Console.Write($"{item} ");
        }
    }
}

Javascript

class TreeNode {
  constructor(val) {
    this.value = val;
    this.left = null;
    this.right = null;
  }
}

function nodeExists(root, targetValue) {
  if (root === null) {
    return false;
  }

  if (root.value === targetValue) {
    return true;
  }

  return nodeExists(root.left, targetValue) || nodeExists(root.right, targetValue);
}

function findNodeNeighbors(root, targetValue) {
  const ans = [];

  if (root === null) {
    return [];
  }

  const queue = [root];
  while (queue.length > 0) {
    const size = queue.length;
    const ds = [];

    for (let i = 0; i < size; i++) {
      const temp = queue.shift();
      ds.push(temp.value);

      if (temp.left !== null) {
        queue.push(temp.left);
      }

      if (temp.right !== null) {
        queue.push(temp.right);
      }
    }

    ans.push(ds);
  }

  for (const it of ans) {
    if (it.includes(targetValue)) {
      return it;
    }
  }

  return [];
}

// Driver code
const root = new TreeNode(1);
root.left = new TreeNode(2);
root.right = new TreeNode(3);
root.left.left = new TreeNode(4);
root.left.right = new TreeNode(5);
root.right.left = new TreeNode(6);
root.right.right = new TreeNode(7);

const targetValue = 4;
const ans = [];

if (nodeExists(root, targetValue)) {
  console.log(`Node with value ${targetValue} exists.`);
  ans.push(...findNodeNeighbors(root, targetValue));
} else {
  console.log(`Node with value ${targetValue} does not exist.`);
}

console.log("Neighbours are:");
console.log(ans.join(" "));

// Deallocate memory (JavaScript automatically manages memory)

Output

Node with value 4 exists.
Neighbours are:
4 5 6 7 

Time Complexity: O(N), where N is the number of nodes in the binary tree.
Auxiliary space: O(N), where N is the number of nodes in the binary tree.