Queries to calculate sum of the path from root to a given node in given Binary Tree
Last Updated :
29 Oct, 2023
Given an infinite complete binary tree rooted at node 1, where every ith node has two children, with values 2 * i and 2 * (i + 1). Given another array arr[] consisting of N positive integers, the task for each array element arr[i] is to find the sum of the node values that occur in a path from the root node to the node arr[i].
Examples:
Input: arr[] = {3, 10}
Output: 4 18
Explanation:
Node 3: The path is 3 -> 1. Therefore, the sum of the path is 4.
Node 10: The path is 10 -> 5 -> 2 -> 1. Therefore, the sum of node is 18.
Input: arr[] = {1, 4, 20}
Output: 1 7 38
Explanation:
Node 1: The path is 1. Therefore, the sum of the path is 1.
Node 4: The path is 4 -> 2 -> 1. Therefore, the sum of node is 7.
Node 20: The path is 20 -> 10 -> 5 -> 2 -> 1. Therefore, the sum of node is 38.
Naive Approach: The simplest approach is to perform DFS Traversal for each array element arr[i] to find its path from the current node to the root and print the sum of the node values in that path.
Time Complexity: O(N * H), where H is the maximum height of the tree.
Auxiliary Space: O(H)
Optimized Approach: In this approach we will be creating a function to find the sum of node values along the path for each element in the given array arr[] and a function to find the sum of node values along the path from the root node to a given node.
Step by step algorithm:
- Initialize sum to 0.
- Traverse the binary tree from the given node to the root node.
- At each node, add the node value to the sum.
- Update the current node to its parent node.
- Repeat steps 3-4 until the current node is the root node.
- Add the root node value to the sum.
- Return the sum.
C++
#include <bits/stdc++.h>
using namespace std;
int findPathSum(int n) {
int sum = 0;
while (n != 1) {
sum += n;
n /= 2;
}
sum += 1;
return sum;
}
vector<int> findPathSums(vector<int>& arr) {
vector<int> pathSums;
for (int n : arr) {
int pathSum = findPathSum(n);
pathSums.push_back(pathSum);
}
return pathSums;
}
int main() {
vector<int> arr = {1, 4, 20};
vector<int> pathSums = findPathSums(arr);
for (int sum : pathSums) {
cout << sum << " ";
}
cout << endl;
return 0;
}
|
Java
import java.util.*;
public class Main {
static int findPathSum(int n) {
int sum = 0;
while (n != 1) {
sum += n;
n /= 2;
}
sum += 1;
return sum;
}
static List<Integer> findPathSums(List<Integer> arr) {
List<Integer> pathSums = new ArrayList<>();
for (int n : arr) {
int pathSum = findPathSum(n);
pathSums.add(pathSum);
}
return pathSums;
}
public static void main(String[] args) {
List<Integer> arr = Arrays.asList(1, 4, 20);
List<Integer> pathSums = findPathSums(arr);
for (int sum : pathSums) {
System.out.print(sum + " ");
}
System.out.println();
}
}
|
Python3
def find_path_sum(n):
sum = 0
while n != 1:
sum += n
n //= 2
sum += 1
return sum
def find_path_sums(arr):
path_sums = []
for n in arr:
path_sum = find_path_sum(n)
path_sums.append(path_sum)
return path_sums
if __name__ == "__main__":
arr = [1, 4, 20]
path_sums = find_path_sums(arr)
for sum in path_sums:
print(sum, end=" ")
print()
|
C#
using System;
using System.Collections.Generic;
class GFG {
static int findPathSum(int n)
{
int sum = 0;
while (n != 1) {
sum += n;
n /= 2;
}
sum += 1;
return sum;
}
static List<int> findPathSums(List<int> arr)
{
List<int> pathSums = new List<int>();
foreach(int n in arr)
{
int pathSum = findPathSum(n);
pathSums.Add(pathSum);
}
return pathSums;
}
public static void Main(string[] args)
{
List<int> arr = new List<int>{ 1, 4, 20 };
List<int> pathSums = findPathSums(arr);
foreach(int sum in pathSums)
{
Console.Write(sum + " ");
}
Console.WriteLine();
}
}
|
Javascript
function findPathSum(n) {
let sum = 0;
while (n !== 1) {
sum += n;
n = Math.floor(n / 2);
}
sum += 1;
return sum;
}
function findPathSums(arr) {
const pathSums = [];
for (const n of arr) {
const pathSum = findPathSum(n);
pathSums.push(pathSum);
}
return pathSums;
}
const arr = [1, 4, 20];
const pathSums = findPathSums(arr);
console.log(pathSums.join(" "));
|
Time complexity: O(NlogN), where N is the number of elements in the given array arr.
Auxiliary Space: O(N), where N is the number of elements in the given array arr.
Efficient Approach: The above approach can also be optimized based on the observation that the parent of the node with value N contains the value N/2. Follow the steps below to solve the problem:
- Initialize a variable, say sumOfNode, to store the sum of nodes in a path.
- Traverse the array arr[i] and perform the following steps:
- For each element arr[i], update the value of sumOfNode as sumOfNode + X and update arr[i] as arr[i] / 2.
- Repeat the above steps while arr[i] is greater than 0.
- Print the value of sumOfNode as the result for each array element arr[i].
Below is the implementation of the above approach:
C++
#include <iostream>
#include <vector>
using namespace std;
void sumOfNodeInAPath(int node_value)
{
int sum_of_node = 0;
while (node_value) {
sum_of_node += node_value;
node_value /= 2;
}
cout << sum_of_node;
return;
}
void findSum(vector<int> Q)
{
for (int i = 0; i < Q.size(); i++) {
int node_value = Q[i];
sumOfNodeInAPath(node_value);
cout << " ";
}
}
int main()
{
vector<int> arr = { 1, 5, 20, 100 };
findSum(arr);
return 0;
}
|
Java
import java.io.*;
import java.util.ArrayList;
class GFG {
public static void sumOfNodeInAPath(int node_value)
{
int sum_of_node = 0;
while (node_value > 0) {
sum_of_node += node_value;
node_value /= 2;
}
System.out.print(sum_of_node);
}
public static void findSum(ArrayList<Integer> Q)
{
for (int i = 0; i < Q.size(); i++) {
int node_value = Q.get(i);
sumOfNodeInAPath(node_value);
System.out.print(" ");
}
}
public static void main(String[] args)
{
ArrayList<Integer> arr = new ArrayList<>();
arr.add(1);
arr.add(5);
arr.add(20);
arr.add(100);
findSum(arr);
}
}
|
Python3
def sumOfNodeInAPath(node_value):
sum_of_node = 0
while (node_value):
sum_of_node += node_value
node_value //= 2
print(sum_of_node, end = " ")
def findSum(Q):
for i in range(len(Q)):
node_value = Q[i]
sumOfNodeInAPath(node_value)
print(end = "")
arr = [1, 5, 20, 100]
findSum(arr)
|
C#
using System;
using System.Collections.Generic;
class GFG{
public static void sumOfNodeInAPath(int node_value)
{
int sum_of_node = 0;
while (node_value > 0) {
sum_of_node += node_value;
node_value /= 2;
}
Console.Write(sum_of_node);
}
public static void findSum(List<int> Q)
{
for (int i = 0; i < Q.Count ; i++) {
int node_value = Q[i];
sumOfNodeInAPath(node_value);
Console.Write(" ");
}
}
static public void Main()
{
List<int> arr = new List<int>();
arr.Add(1);
arr.Add(5);
arr.Add(20);
arr.Add(100);
findSum(arr);
}
}
|
Javascript
<script>
function sumOfNodeInAPath(node_value)
{
let sum_of_node = 0;
while (node_value) {
sum_of_node += node_value;
node_value = Math.floor(node_value / 2 );
}
document.write(sum_of_node);
return;
}
function findSum( Q)
{
for (let i = 0; i < Q.length; i++) {
let node_value = Q[i];
sumOfNodeInAPath(node_value);
document.write(" ");
}
}
let arr = [ 1, 5, 20, 100 ];
findSum(arr);
</script>
|
Time Complexity: O(N*log X), where X is the maximum element of the array.
Auxiliary Space: O(1)
Like Article
Suggest improvement
Share your thoughts in the comments
Please Login to comment...