Number of Siblings of a given node in n-arr tree

A node's number of siblings in an N-ary tree is determined by its specific tree structure and its placement within it. Nodes that have the same parent in the tree are called siblings.

Example:

Number of Siblings of a given node in n-arr tree

Input: 30

Output :3

Implementation:

Approach: Move the offspring of the current node up the queue for each node in the provided n-ary tree. Verify whether any of the current node's offspring equals the specified value x before adding them to the queue. Return's sibling count if the answer is affirmative.

In java:

import java.util.*;
public class SiblingCountCalculator {
    static class Node {
        int key;
        Vector<Node> children;
        Node(int data) {
            key = data;
            children = new Vector<Node>();
        }
    }
    static int calculateNumberOfSiblings(Node root, int x) 
     {
        if (root == null)
            return 0;
        Queue<Node> queue = new LinkedList<>();
        queue.add(root);
        while (!queue.isEmpty()) 
           {
            Node currentNode = queue.peek();
            queue.remove();
            for (int i = 0; i < currentNode.children.size(); i++) {
                if (currentNode.children.get(i).key == x)
                    return currentNode.children.size() - 1;
                queue.add(currentNode.children.get(i));
            }
        }
        return -1;
    }
    public static void main(String args[]) {
        Node root = new Node(50);
        (root.children).add(new Node(2));
        (root.children).add(new Node(30));
        (root.children).add(new Node(14));
        (root.children).add(new Node(60));
        (root.children.get(0).children).add(new Node(15));
        (root.children.get(0).children).add(new Node(25));
        (root.children.get(0).children.get(1).children).add(new Node(70));
        (root.children.get(0).children.get(1).children).add(new Node(100));
        (root.children.get(1).children).add(new Node(6));
        (root.children.get(1).children).add(new Node(1));
        (root.children.get(2).children).add(new Node(7));
        (root.children.get(2).children.get(0).children).add(new Node(17));
        (root.children.get(2).children.get(0).children).add(new Node(99));
        (root.children.get(2).children.get(0).children).add(new Node(27));
        (root.children.get(3).children).add(new Node(16));
        int x = 100;
        System.out.println("Number of siblings for node " + x + " is: " + calculateNumberOfSiblings(root, x));
    }
}

Output:

Number of siblings for node 100 is: 1

A tree structure and a function to determine how many siblings a node has for a given key value (x) are defined in the Java code. To navigate the tree, it employs a breadth-first search (BFS) strategy. As it searches for a match with x, the BFS enqueues nodes starting at the root. If a match is discovered, the number of siblings for that node is obtained by deducting one from the total number of children of the parents. It returns -1 to show that the node was absent from the tree if no match is found. The code determines that node 70-the node associated with key 100-has one sibling. It then shows this information.

Complexity Analysis:

Time complexity: O(N) is the time complexity, where N is the number of nodes in the tree.

Space Complexity: O(N) , Where N is the number of nodes in a tree.

Another Example:

Algorithmic procedures for putting the idea into practice:

To keep track of each node's parent, make a hash map.
Map each tree node to its parent using the hash map.
Look up the parent node in the hash map for the node for which you wish to get the number of siblings.
Return 0 since the node has no siblings if the parent cannot be located.
Determine the parent's child count if they are located.
Since the specified node is a part of the count, return the count minus 1.

Note: The accuracy and completeness of the parent array as a representation of the n-ary tree is assumed by this technique.

In java:

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
public class SiblingCounter {
    // Define a method to count the number of siblings for a given node in a tree
    public static int findSiblingCount(int node, Map<Integer, List<Integer>> treeMap) {
        int parent = treeMap.containsKey(node) ? treeMap.get(node).get(0) : -1;
        if (parent == -1) {
            return 0;
        } 
        int siblingCount = treeMap.get(parent).size() - 1;
        return siblingCount;
    }
    public static void main(String[] args) {
        // Define the tree using a map of integer keys and lists of integers as values
        Map<Integer, List<Integer>> treeMap = new HashMap<>();
        //Example tree structure
        treeMap.put(0, List.of(-1, 1, 2, 3));
        treeMap.put(1, List.of(0, 4, 5));
        treeMap.put(2, List.of(0, 6));
        treeMap.put(3, List.of(0));
        treeMap.put(4, List.of(1));
        treeMap.put(5, List.of(1));
        treeMap.put(6, List.of(2));
        int node = 4;
        // Call the findSiblingCount method and print the result
        System.out.println("The number of siblings for node " + node + " is: " + findSiblingCount(node, treeMap));
    }
}sss

Output:

The number of siblings for node 4 is: 2

The number of siblings for a specific node in a tree that is represented by a map is determined by the Java code. It defines a function called findSiblingCount that accepts a map that depicts the tree topology as well as a node. The process begins by identifying the parent of the specified node, after which it deducts one from the parent's total number of children to get the number of siblings. The output in the Example with node = 4 is 2, meaning that the node with key 4 has two siblings in the tree. Readability has been increased in the code structure without affecting the underlying reasoning.

Time Complexity: Because it takes a constant amount of time for the findSiblingCount function to determine a node's siblings, the code above has an O(1) time complexity. This is because each node's parent is stored in the hash map, making it constantly time-consuming to find the parent of a particular node. This also applies to calculating the parent's child count.

Space Complexity: The space complexity of the code mentioned is O(n), where n is the number of nodes in the n-ary tree. This is due to the fact that the hash map is used to store the parent and children of each node. Hence, the amount of space required grows linearly with the number of nodes in the tree.

Next TopicNumber of ways to traverse an N-arr

← prev next →