Find the Root of a Tree from the Sum of Child Node IDs

Given a Binary Tree with nodes labelled from 1 to n, where n is the total number of nodes. The task is to identify the root of binary tree given that each node is described by a pair consisting of its id and the sum of its children's id's.

Examples:

Input: [[1, 5], [2, 0], [3, 0], [4, 0], [5, 5], [6, 5]]
Output: 6
Explanation: In this question, two trees having 6 as their root node can me generated.

Input: [[4, 0]
Output: 4
Explanation: 4 is the only node in a tree and thus does not have any child as well.

Approach:

The idea is to use the property that every node id, except for the root, appears in the sum of children ids. By calculating the total sum of all node id's and subtracting it to the total sum of all children sum, the difference will be the id of the root node.

C++

// C++ Program to Find root of tree where children
// sum for every node id is given.
#include <bits/stdc++.h>
using namespace std;

int findRoot(vector<pair<int, int>> &arr) {

    // Subtract the sum of children
    //  from the sum of all nodes
    int root = 0;
    for (int i = 0; i < arr.size(); i++) {

        // Add the node Id to the root
        root += arr[i].first;

        // Subtract the sum of children
        root -= arr[i].second;
    }

    return root;
}

int main() {
    vector<pair<int, int>> arr = 
    {{1, 5}, {2, 0}, {3, 0}, {4, 0}, {5, 5}, {6, 5}};

    // The given array represents the following binary tree
    //    6          6
    //    \         / \
    //     5       1   4
    //    / \       \
    //   1   4       5
    //  / \         / \
    // 2   3       2   3

    int res = findRoot(arr);
    cout << res << endl;
    return 0;
}

Java

// Java Program to Find root of tree where
// children sum for every node id is given.

class GfG {

    static class pair {

        int first, second;

        public pair(int first, int second) {
            this.first = first;
            this.second = second;
        }
    }

    static int findRoot(pair arr[]) {

        // Subtract the sum of children
        //  from the sum of all nodes
        int root = 0;
        for (int i = 0; i < arr.length; i++) {

            // Add the node Id to the root
            root += arr[i].first;

            // Subtract the sum of children
            root -= arr[i].second;
        }

        // Return the root of the tree
        return root;
    }

    public static void main(String[] args) {
        pair arr[] = { new pair(1, 5), new pair(2, 0),
                       new pair(3, 0), new pair(4, 0),
                       new pair(5, 5), new pair(6, 5) };

        // The given array represents the following binary
        // tree
        //    6          6
        //    \         / \
        //     5       1   4
        //    / \       \
        //   1   4       5
        //  / \         / \
        // 2   3       2   3

        System.out.print(findRoot(arr));
    }
}

Python

# Python Program to Find root of tree where 
# children sum for every node id is given.

def findRoot(arr) :

    # Subtract the sum of children
    #  from the sum of all nodes
    root = 0
    for i in range(len(arr)):
       
        # Add the node Id to the root
        root += arr[i][0]

        # Subtract the sum of children
        root -= arr[i][1]

    # Return the root of the tree
    return root

if __name__ == '__main__':

    arr = [[1, 5], [2, 0], 
           [3, 0], [4, 0], 
           [5, 5], [6, 5]] 
    
    #The given array represents the following binary tree
    #    6          6
    #    \         / \
    #     5       1   4
    #    / \       \
    #   1   4       5
    #  / \         / \
    # 2   3       2   3
    
    print(findRoot(arr))

// C# Program to Find root of tree where
// children sum for every node id is given.
using System;
class GfG {
    public class pair {
        public int first, second;
        public pair(int first, int second) {
            this.first = first;
            this.second = second;
        }
    }

    static int findRoot(pair[] arr) {

        // Subtract the sum of children
        //  from the sum of all nodes
        int root = 0;
        for (int i = 0; i < arr.Length; i++) {

            // Add the node Id to the root
            root += arr[i].first;

            // Subtract the sum of children
            root -= arr[i].second;
        }

        // Return the root of the tree
        return root;
    }

    static void Main(String[] args) {
        pair[] arr = { new pair(1, 5), new pair(2, 0),
                       new pair(3, 0), new pair(4, 0),
                       new pair(5, 5), new pair(6, 5) };

        // The given array represents the following binary
        // tree
        //    6          6
        //    \         / \
        //     5       1   4
        //    / \       \
        //   1   4       5
        //  / \         / \
        // 2   3       2   3

        Console.Write(findRoot(arr));
    }
}

JavaScript

// JavaScript to Find root of tree where
// children sum for every node id is given.

function findRoot(arr) {

    // Subtract the sum of children
    //  from the sum of all nodes
    let root = 0;
    for (let i = 0; i < arr.length; i++) {

        // Add the node Id to the root
        root += arr[i][0];

        // Subtract the sum of children
        root -= arr[i][1];
    }

    // Return the root of the tree
    return root;
}

let arr = [
    [ 1, 5 ], [ 2, 0 ], [ 3, 0 ], [ 4, 0 ], [ 5, 5 ],
    [ 6, 5 ]
];

// The given array represents the following binary tree
//    6          6
//    \         / \
//     5       1   4
//    / \       \
//   1   4       5
//  / \         / \
// 2   3       2   3

console.log(findRoot(arr));

Output

Time Complexity: O(n), Where n is the length of the given array.
Auxiliary Space: O(1), As no extra space is used.

Find the Root of a Tree from the Sum of Child Node IDs

Explore