TLDR

1. Welcome!

2. Turning software to be product-oriented with ELEKS

3. Help your wellbeing with this free assessment from BetterHelp

4. 637. Average of Levels in Binary Tree

5. Recommendations I live by!

6. Self-Gaslight of the week

7. JOBS & SCHOLARSHIPS

Day 2: 637. Average of Levels in Binary Tree

Given the root of a binary tree, return the average value of the nodes on each level in the form of an array. 

Before we dive in,

Breathe

Nothing is ever that deep.

Now, let’s

But there is a little trick that I am about to teach you….

We’re going to leverage recursion to navigate through the tree and a map to store the nodes level by level, where the key is the level and the value is an array with the nodes in that level.

We are simply going to iterate through the tree, store in our map the current node we are processing and their level:

treeNodes[level].push_back(root->val);

And every time we call our recursive function, we’re simply going to add 1 to our level so that when we traverse deeper into the tree, we know exactly where we are:

auxLevelOrder(root->left, level + 1); 
auxLevelOrder(root->right, level + 1);

This approach allows us to group nodes together by their levels as we go down the tree.

Once we have a map with the levels and nodes, we are going to find the average of each level simply by iterating through each level, summing the value of each node, and dividing it by the size of the array, resulting in the average value for that particular level.

Once the average is calculated, we add simply add it to our results array.

Complete code:

class Solution {
public:
    map<int, vector<int>> nodes_by_level; // The key is the level, the value is the list of nodes at that level

    // Helper function to recursively traverse the tree and group nodes by level
    void auxAverageOfLevels(TreeNode* root, int level) {
        if (root == NULL) {
            return;
        }
        auxAverageOfLevels(root->left, level + 1); // Traverse left subtree
        nodes_by_level[level].push_back(root->val); // Store the current node's value
        auxAverageOfLevels(root->right, level + 1); // Traverse right subtree
    }

    // Main function to compute the average of each level
    vector<double> averageOfLevels(TreeNode* root) {
        vector<double> average_of_levels;
        auxAverageOfLevels(root, 0); // Start traversal from the root at level 0

        // Iterate over each level in the map
        for (const auto& [level, nodes] : nodes_by_level) {
            double sum_of_level = 0;
            // Calculate the sum of nodes at the current level
            for (int node_value : nodes) {
                sum_of_level += node_value;
            }
            // Compute the average and add it to the result vector
            average_of_levels.push_back(sum_of_level / nodes.size());
        }

        return average_of_levels;
    }
}

Recommendations

Level up your inbox by subscribing to what I am subscribed to!

Self-gaslight of the week

I truly believe you can gaslight yourself to success.

1. When in doubt, ask, what would the main character do?

2. Act like you already have the job and outwork everyone

Jobs and Scholarships

1. New scholarships of this week!

2. Entry level jobs!!