Find the Absolute Difference between the Right View Sum of two Binary Trees

Introduction

In computer science, binary trees are a basic type of data structure that is often used to depict hierarchical relationships. Finding the absolute difference in the sums of the nodes visible from the right perspective of two binary trees is an interesting topic in binary tree manipulation. To solve this problem, a combination of recursion, tree traversal, and mathematical operations is used. Our goal is to determine the absolute difference between the sums of the nodes visible from each tree's right perspective, given two binary trees. The set of nodes that are visible while looking at a binary tree from its right side is known as the right view. Put otherwise, it encompasses the level's rightmost node at every level.

Algorithmic Approach

A recursive strategy is one that we can use to solve this problem. The goal is to go through both trees at the same time, recording the total number of nodes that are visible at each level from the right view. The absolute difference between the sums acquired from the two trees can then be computed.

Algorithm

Beginning at both trees' roots, begin the traversal.
Update the total number of nodes shown from the right view at each level.
Go through the left subtree after the right subtree. This makes sure that at every level, the node farthest to the right is given priority.
For each tree, repeat the procedure.
Determine the absolute difference between the sums of the two trees' right views.

Code

#include <stdio.h>
#include <stdlib.h>
struct TreeNode {
    int val;
    struct TreeNode* left;
    struct TreeNode* right;
};
int findRightViewDifference(struct TreeNode* root1, struct TreeNode* root2) {
    if (root1 == NULL && root2 == NULL) {
        return 0;
    }
    int sum1 = 0, sum2 = 0;
    void calculateRightViewSum(struct TreeNode* root, int level, int* sum) {
        if (root == NULL) {
            return;
        }
        if (level > *sum) {
            *sum += root->val;
        }
        calculateRightViewSum(root->right, level + 1, sum);
        calculateRightViewSum(root->left, level + 1, sum);
    }
    calculateRightViewSum(root1, 1, &sum1);
    calculateRightViewSum(root2, 1, &sum2);
    return abs(sum1 - sum2);
}
int main() {
    struct TreeNode* root1 = (struct TreeNode*)malloc(sizeof(struct TreeNode));
    root1->val = 1;
    root1->left = (struct TreeNode*)malloc(sizeof(struct TreeNode));
    root1->left->val = 2;
    root1->left->left = NULL;
    root1->left->right = NULL;
    root1->right = (struct TreeNode*)malloc(sizeof(struct TreeNode));
    root1->right->val = 3;
    root1->right->left = NULL;
    root1->right->right = NULL;
    struct TreeNode* root2 = (struct TreeNode*)malloc(sizeof(struct TreeNode));
    root2->val = 4;
    root2->left = (struct TreeNode*)malloc(sizeof(struct TreeNode));
    root2->left->val = 5;
    root2->left->left = NULL;
    root2->left->right = NULL;
    root2->right = (struct TreeNode*)malloc(sizeof(struct TreeNode));
    root2->right->val = 6;
    root2->right->left = NULL;
    root2->right->right = NULL;
    int result = findRightViewDifference(root1, root2);
    printf("Absolute Difference between Right View Sums: %d\n", result);
    free(root1->left);
    free(root1->right);
    free(root1);
    free(root2->left);
    free(root2->right);
    free(root2);
    return 0;
}

Output:

Find the Absolute Difference between the Right View Sum of two Binary Trees

Code Explanation

Header Files

The code provides the stdio.h and stdlib.h header files required for standard input/output and dynamic memory allocation.

Definition of Structure

A node in a binary tree is represented by the struct TreeNode. It has references to the children on the left and right as well as an integer value (val).

Function: findRightViewDifference

The absolute difference in the sums of the nodes that are visible from the right perspective of two binary trees is computed by this function.
The two arguments, root1 and root2, which stand for the two binary trees' roots, are required.
The function traverses the trees and determines the right view total for each tree using a recursive helper function called calculateRightViewSum.

Recursive Helper Function: calculateRightViewSum

This function determines the binary tree's right view sum.
Three parameters are required: root (the tree's current root), level (the tree's current level), and sum (a pointer to the sum variable).
The left subtree is traversed recursively after the right subtree.
It updates the total with the value of the current node at each level if the current level exceeds the stored right view level (*sum). This guarantees that for the right view sum, only the rightmost node at each level is taken into account.

Main Function

The program's entrance point is the main function.
Using malloc, two binary trees (root1 and root2) are dynamically generated and filled with data.
With these two trees, the findRightViewDifference function is called, and the outcome is written to the console.
To stop memory leaks, the memory allotted for the tree nodes is released for free.

Example Trees

For testing reasons, two example binary trees are built in the main function. To test the functionality, you can make changes to these trees or build your own.

Print Result