Find the number of colored nodes according to given queries in a full Binary Tree

Introduction:

Binary trees are basic data structures that are used in computer science and mathematics. A full binary tree is a sort of binary tree in which each node has one or two offspring. Each node in a complete binary tree can be colored, and calculating the number of colored nodes depending on specific queries adds an interesting layer of complexity. In this article, we will look at how to calculate the number of colored nodes in a whole binary tree based on specified queries.

Full Binary Tree:

Every node in a complete binary tree has either zero or two offspring. This topology ensures that nodes are distributed in a balanced and symmetric manner, which simplifies certain operations and analyses. A whole binary tree's nodes can be uniquely identifiable by their positions, which are typically referred to as levels and positions within each level.

Node Colouring in a Full Binary Tree:

Before we get started with queries, let's define the concept of coloring nodes in a binary tree. Coloring nodes is a popular practice in algorithms and data structures to identify and process certain nodes. We can give colors to nodes in our entire binary tree based on certain conditions, such as their level or position.

Queries and Coloured Node Counting:

Let's look at how to find the number of colored nodes in a whole binary tree based on specified queries. Queries often entail setting conditions for coloring nodes, with the problem being to navigate the tree efficiently enough to count the nodes that fulfill these constraints.

1. Query Type - Level-Based Coloring:

In this case, queries may specify coloring nodes based on their position in the tree.
A typical query may be to color all nodes at an even level or all nodes at a specific depth.
To do so, use a depth-first or breadth-first traverse to locate and color nodes based on their levels.

2. Query Type - Position-Based Coloring:

Queries may additionally include node coloring dependent on their position inside a level.
Color all nodes in an odd location at a certain level, for example.
This necessitates traversing the tree while keeping track of node placements at each level.

3. Combination of Conditions:

The task becomes more complex when queries incorporate conditions related to position and level.
Effective algorithms that take into account both location and level criteria, including recursive or iterative techniques, can be developed to move through the tree.

Strategies for Traversals:

1. Depth-First Traversal:

For issues involving trees, recursive or iterative depth-first traversal is frequently utilized.
The offered code takes a depth-first, recursive approach.

2. Breadth-First Traversal:

A queue data structure can also be used for iterative breadth-first traversal.
Helpful when circumstances require nodes to be at the same level.

Implementation:

#include <stdio.h>
#include <stdlib.h>
struct Node {
    int data;
    struct Node* left;
    struct Node* right;
    int color; 
};
struct Node* createNode(int data) {
    struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
    newNode->data = data;
    newNode->left = NULL;
    newNode->right = NULL;
    newNode->color = 0; 
    return newNode;
}
int countColoredNodes(struct Node* root, int levelCondition, int positionCondition, int currentLevel, int currentPosition) {
    if (root == NULL) {
        return 0;
    }
    int coloredNodes = 0;
    if (currentLevel % levelCondition == 0 && currentPosition % positionCondition == 0) {
        root->color = 1; 
        coloredNodes = 1;
    }
    coloredNodes += countColoredNodes(root->left, levelCondition, positionCondition, currentLevel + 1, currentPosition * 2);
    coloredNodes += countColoredNodes(root->right, levelCondition, positionCondition, currentLevel + 1, currentPosition * 2 + 1);
    return coloredNodes;
}
int main() {
    struct Node* root = createNode(1);
    root->left = createNode(2);
    root->right = createNode(3);
    root->left->left = createNode(4);
    root->left->right = createNode(5);
    root->right->left = createNode(6);
    root->right->right = createNode(7);
    int levelCondition = 2;
    int positionCondition = 2;
    int coloredNodes = countColoredNodes(root, levelCondition, positionCondition, 1, 1);
    printf("Number of colored nodes: %d\n", coloredNodes);
    return 0;
}

Output:

Number of colored nodes: 1

Using an even level and odd position query, this program initializes a sample full binary tree and counts the number of colored nodes. To test various queries, you can change the levelCondition and positionCondition variables.

Time Complexity: O(N)

Space Complexity: O(N)

The balance of the tree is assumed in this analysis. The height becomes N and the space complexity for the recursion stack becomes O(N) if the tree is unbalanced and, in the worst scenario, degenerates into a linked list. On the other hand, the height of a complete binary tree is O(logN), meaning that the total space complexity is O(N).

Next TopicFinding Minimum Steps in Special Binary Tree

← prev next →