Question

I’m trying to write a method for the maximum sum of a path through a binary tree:

public class ConsTree<T> extends BinaryTree<T>
{
    BinaryTree<T> left;
    BinaryTree<T> right;
    T data;

    public int maxSum() 
    {
    }
} 

As is shown, each tree contains a tree to its left and to its right, as well as a data of a generic type. I am somewhat confused on how to go about starting this. If someone could provide help as to what the algorithm might look like or put me in the right direction, that would be great. Thanks.

Answer 1

The way to think recursively is to consider the cases. In our case, we look at a single node and can decide what paths it has:

1. If the node has no children, then the only path is the singleton path (consisting of that node by itself).
2. If the node has only one child, then all paths go through that child.
3. Otherwise, the node has two children. Then, all paths go through one of its two children.

In case 1, the maximum must be that node’s value. In case 2, the maximum is that node’s value, plus the max-path-sum of its child (since that path is extended to a path for the parent through the only child). In case 3, the maximum is the maximum max-path-sum of its two children (since the best path must go through one of the two children, and the parent can see which of the children’s best paths is better).

Therefore, the code is really simple. Here, since you return an int, I’m going to assume T = int.

public int maxSum() {
    /* case 1 */
    if(left == null && right == null)
        return data;

    /* case 2 */
    if(right == null)
        return data + left.maxSum();
    else if(left == null)
        return data + right.maxSum();

    /* case 3 */
    return Math.max(data + left.maxSum(), data + right.maxSum());
}