Maximum Sum of Non-Adjacent Nodes

Last Updated : 6 Oct, 2025

Given the root of a binary tree with integer values, Find the maximum sum of node values such that no two nodes connected by an edge are both included in the sum.

Examples:  

Input:

420046795

Output: 11
Explanation: The maximum sum is sum of node 11.

420046796

Input:

420046758

Output: 27
Explanation: The maximum sum is sum of nodes 15, and 12, i.e., 27. These nodes are non adjacent.

420046759
Try It Yourself
redirect icon

Table of Content

[Naive Approach] Using Recursion

We can solve this problem by considering the fact that both node and its immediate children can’t be in sum at the same time.

  • Include the current node's value in the sum: In this case, we cannot include the values of its immediate children in the sum. Therefore, we recursively call the function on the grandchildren of the current node.
  • Exclude the current node's value in the sum: In this case, we are allowed to include the values of its immediate children in the sum. So, we recursively call the function on the immediate children of the current node.
  • Finally we will choose maximum from both of the results. 
C++ 
#include <iostream>
#include <algorithm>
using namespace std;

// Node Structure
class Node {
public:
    int data;
    Node* left;
    Node* right;

    Node(int x) {
        data = x;
        left = right = NULL;
    }
};


// method to return the maximum 
// sum rooted at the node 'node'
int getMaxSumUtil(Node* node) {
    if (node == NULL) return 0;

    int includeNode = node->data;

    if (node->left != NULL) {
        includeNode += getMaxSumUtil(node->left->left) +
                       getMaxSumUtil(node->left->right);
    }

    if (node->right != NULL) {
        includeNode += getMaxSumUtil(node->right->left) +
                       getMaxSumUtil(node->right->right);
    }

    int excludeNode = getMaxSumUtil(node->left) + 
                      getMaxSumUtil(node->right);

    // The result for the current node is the
    // maximum of including or excluding it
    return max(includeNode, excludeNode);
}

int getMaxSum(Node* root) {
    if (root == NULL) return 0;
    return getMaxSumUtil(root);
}

int main() {
    
    // Create binary tree
    //          1
    //         / \
    //        2   3
    //       /   / \
    //      1   4   5
    Node* root = new Node(1);
    root->left = new Node(2);
    root->right = new Node(3);
    root->right->left = new Node(4);
    root->right->right = new Node(5);
    root->left->left = new Node(1);

    cout << getMaxSum(root) << endl;
    return 0;
}
Java 
// Node Structure
class Node {
    int data;
    Node left, right;
    
    Node(int x) {
        data = x;
        left = right = null;
    }
}

class GFG {
    
    // method to return the maximum 
    // sum rooted at the node 'node'
    static int getMaxSumUtil(Node node) {
        if (node == null) return 0;
        
        int includeNode = node.data;
        
        if (node.left != null) {
            includeNode += getMaxSumUtil(node.left.left) + 
                           getMaxSumUtil(node.left.right);
        }
        
        if (node.right != null) {
            includeNode += getMaxSumUtil(node.right.left) + 
                           getMaxSumUtil(node.right.right);
        }

        int excludeNode = getMaxSumUtil(node.left) + 
                          getMaxSumUtil(node.right);

        // The result for the current node is the
      	// maximum of including or excluding it
        return Math.max(includeNode, excludeNode);
    }

    static int getMaxSum(Node root) {
        if (root == null) return 0;
        
        return getMaxSumUtil(root);
    }

    public static void main(String[] args) {
      
        // Create binary tree
        //          1
        //         / \
        //        2   3
        //       /   / \
        //      1   4   5
        Node root = new Node(1);
        root.left = new Node(2);
        root.right = new Node(3);
        root.right.left = new Node(4);
        root.right.right = new Node(5);
        root.left.left = new Node(1);

        System.out.println(getMaxSum(root));
    }
}
Python 
# Node Structure
class Node:
    def __init__(self, x):
        self.data = x
        self.left = None
        self.right = None



# method to return the maximum 
# sum rooted at the node 'node'
def getMaxSumUtil(node):
    if node is None:
        return 0

    includeNode = node.data

    if node.left is not None:
        includeNode += getMaxSumUtil(node.left.left) + \
                       getMaxSumUtil(node.left.right)

    if node.right is not None:
        includeNode += getMaxSumUtil(node.right.left) + \
                       getMaxSumUtil(node.right.right)

    excludeNode = getMaxSumUtil(node.left) + \
                  getMaxSumUtil(node.right)

    # The result for the current node is the
    # maximum of including or excluding it
    return max(includeNode, excludeNode)

def getMaxSum(root):
    if root is None:
        return 0
    return getMaxSumUtil(root)

if __name__ == "__main__":
    # Create binary tree
    #          1
    #         / \
    #        2   3
    #       /   / \
    #      1   4   5
    root = Node(1)
    root.left = Node(2)
    root.right = Node(3)
    root.right.left = Node(4)
    root.right.right = Node(5)
    root.left.left = Node(1)
    
    print(getMaxSum(root))
C# 
using System;

// Node Structure
class Node {
    public int data;
    public Node left, right;

    public Node(int x) {
        data = x;
        left = right = null;
    }
}

class GFG {
  
    // method to return the maximum 
  	// sum rooted at the node 'node'
    static int getMaxSumUtil(Node node) {
        if (node == null) return 0;
        
        int includeNode = node.data;
        if (node.left != null) {
            includeNode += getMaxSumUtil(node.left.left) + 
              		       getMaxSumUtil(node.left.right);
        }

        if (node.right != null) {
            includeNode += getMaxSumUtil(node.right.left) + 
              		       getMaxSumUtil(node.right.right);
        }

        int excludeNode = getMaxSumUtil(node.left) +
                          getMaxSumUtil(node.right);
       
        // The result for the current node is
      	// the maximum of including or excluding it
        return Math.Max(includeNode, excludeNode);
    }

    static int getMaxSum(Node root) {
        if (root == null) return 0;
        
        return getMaxSumUtil(root);
    }

    static void Main(string[] args) {
      
        // Creating a binary tree with the following structure:
        //          1
        //         / \
        //        2   3
        //       /   / \
        //      1   4   5
        Node root = new Node(1);
        root.left = new Node(2);
        root.right = new Node(3);
        root.right.left = new Node(4);
        root.right.right = new Node(5);
        root.left.left = new Node(1);

        Console.WriteLine(getMaxSum(root));
    }
}
JavaScript 
// Node Structure
class Node {
    constructor(x) {
        this.data = x;
        this.left = null;
        this.right = null;
    }
}

// method to return the maximum 
// sum rooted at the node 'node'
function getMaxSumUtil(node) {
    if (node === null) return 0;

    let includeNode = node.data;

    if (node.left !== null) {
        includeNode += getMaxSumUtil(node.left.left) +
                       getMaxSumUtil(node.left.right);
    }

    if (node.right !== null) {
        includeNode += getMaxSumUtil(node.right.left) +
                       getMaxSumUtil(node.right.right);
    }

    let excludeNode = getMaxSumUtil(node.left) + 
                      getMaxSumUtil(node.right);

    // The result for the current node is the
    // maximum of including or excluding it
    return Math.max(includeNode, excludeNode);
}

function getMaxSum(root) {
    if (root === null) return 0;
    return getMaxSumUtil(root);
}

// Driver code

// Create binary tree
//          1
//         / \
//        2   3
//       /   / \
//      1   4   5
let root = new Node(1);
root.left = new Node(2);
root.right = new Node(3);
root.right.left = new Node(4);
root.right.right = new Node(5);
root.left.left = new Node(1);

console.log(getMaxSum(root));

Output
11

Time Complexity: O(2n),
Auxiliary Space: O(h), where h is height of binary tree due to recursion stack space

[Expected Approach 1] Using Top-Down DP (Memorization) - O(n) Time and O(n) Space

The naive approach leads to recalculating results for the same nodes multiple times. For example, if we include the root node, we recursively compute the sum for its grandchildren (nodes 4 and 5). But if we exclude the root, we compute the sum for its children, and node 3 also computes the sum for its children (4 and 5 again).

To avoid this redundancy, we use memorization:

  • We store the result of each node in a hashmap.
  • When a node's value is needed again, we directly return it from the map instead of recalculating.
C++ 
#include <iostream>
#include <unordered_map>
using namespace std;

// Node Structure
class Node {
public:
    int data;
    Node* left, *right;
    Node(int x) {
        data = x;
        left = right = NULL;
    }
};

// method to return the maximum 
// sum rooted at the node 'node'
int getMaxSumUtil(Node* node, unordered_map<Node*, int>& memo) {
    if (node == NULL) return 0;

    if (memo.find(node) != memo.end()) {
        return memo[node];
    }

    // Calculate the maximum sum 
    // including the current node
    int include = node->data;

    if (node->left != NULL) {
        include += getMaxSumUtil(node->left->left, memo) +
                   getMaxSumUtil(node->left->right, memo);
    }

    if (node->right != NULL) {
        include += getMaxSumUtil(node->right->left, memo) +
                   getMaxSumUtil(node->right->right, memo);
    }

    // Calculate the maximum sum 
    // excluding the current node
    int exclude = getMaxSumUtil(node->left, memo) +
                  getMaxSumUtil(node->right, memo);

    memo[node] = max(include, exclude);
    return memo[node];
}

int getMaxSum(Node* root) {
    unordered_map<Node*, int> memo;
   
    return getMaxSumUtil(root, memo);
}

int main() {
    // Create binary tree 
    //          1
    //         / \
    //        2   3
    //       /   / \
    //      1   4   5
    Node* root = new Node(1);
    root->left = new Node(2);
    root->right = new Node(3);
    root->right->left = new Node(4);
    root->right->right = new Node(5);
    root->left->left = new Node(1);

    cout << getMaxSum(root) << endl;
    return 0;
}
Java 
import java.util.HashMap;

// Node Structure
class Node {
    int data;
    Node left, right;
    
    Node(int x) {
        data = x;
        left = right = null;
    }
}

class GFG {
  
    // method to return the maximum 
  	// sum rooted at the node 'node'
    static int getMaxSumUtil(Node node, HashMap<Node, Integer> memo) {
        if (node == null) return 0;
        
        if (memo.containsKey(node)) {
            return memo.get(node);
        }

        // Calculate the maximum sum 
        // including the current node
        int include = node.data;
        
        if (node.left != null) {
            include += getMaxSumUtil(node.left.left, memo) + 
                    getMaxSumUtil(node.left.right, memo);
        }

        if (node.right != null) {
            include += getMaxSumUtil(node.right.left, memo) + 
                    getMaxSumUtil(node.right.right, memo);
        }

        // Calculate the maximum sum 
        // excluding the current node
        int exclude = getMaxSumUtil(node.left, memo) + 
                   getMaxSumUtil(node.right, memo);

        memo.put(node, Math.max(include, exclude));
        return memo.get(node);
    }

    static int getMaxSum(Node root) {
        HashMap<Node, Integer> memo = new HashMap<>();
        return getMaxSumUtil(root, memo);
    }

    public static void main(String[] args) {
      
        // Create binary tree 
        //          1
        //         / \
        //        2   3
        //       /   / \
        //      1   4   5

        Node root = new Node(1);           
        root.left = new Node(2);             
        root.right = new Node(3);           
        root.right.left = new Node(4);     
        root.right.right = new Node(5);     
        root.left.left = new Node(1);       

        System.out.println(getMaxSum(root));
    }
}
Python 
# Node Structure
class Node:
    def __init__(self, x):
        self.data = x
        self.left = None
        self.right = None


# method to return the maximum 
# sum rooted at the node 'node'
def getMaxSumUtil(node, memo):
    if node is None:
        return 0

    if node in memo:
        return memo[node]

    # Calculate the maximum sum 
    # including the current node
    include = node.data

    if node.left is not None:
        include += getMaxSumUtil(node.left.left, memo) + \
                   getMaxSumUtil(node.left.right, memo)

    if node.right is not None:
        include += getMaxSumUtil(node.right.left, memo) + \
                   getMaxSumUtil(node.right.right, memo)

    # Calculate the maximum sum 
    # excluding the current node
    exclude = getMaxSumUtil(node.left, memo) + getMaxSumUtil(node.right, memo)

    memo[node] = max(include, exclude)
    return memo[node]


def getMaxSum(root):
    memo = {}
    return getMaxSumUtil(root, memo)

if __name__ == "__main__":
    # Create binary tree 
    #          1
    #         / \
    #        2   3
    #       /   / \
    #      1   4   5
    root = Node(1)
    root.left = Node(2)
    root.right = Node(3)
    root.right.left = Node(4)
    root.right.right = Node(5)
    root.left.left = Node(1)
    
    print(getMaxSum(root))
C# 
using System;
using System.Collections.Generic;

// Node Structure
class Node {
    public int data;
    public Node left, right;

    public Node(int x) {
        data = x;
        left = right = null;
    }
}

class GFG {
  
    // method to return the maximum 
    // sum rooted at the node 'node'
    static int getMaxSumUtil(Node node, Dictionary<Node, int> memo) {
        if (node == null) return 0;

        if (memo.ContainsKey(node)) {
            return memo[node];
        }

        // Calculate the maximum sum 
        // including the current node
        int include = node.data;

        if (node.left != null) {
            include += getMaxSumUtil(node.left.left, memo) +
                       getMaxSumUtil(node.left.right, memo);
        }

        if (node.right != null) {
            include += getMaxSumUtil(node.right.left, memo) +
                       getMaxSumUtil(node.right.right, memo);
        }

        // Calculate the maximum sum 
        // excluding the current node
        int exclude = getMaxSumUtil(node.left, memo) +
                      getMaxSumUtil(node.right, memo);

        memo[node] = Math.Max(include, exclude);
        return memo[node];
    }
    
    static int getMaxSum(Node root) {
        Dictionary<Node, int> memo = new Dictionary<Node, int>();
        return getMaxSumUtil(root, memo);
    }

    static void Main(string[] args) {
        // Create binary tree 
        //          1
        //         / \
        //        2   3
        //       /   / \
        //      1   4   5
        
        Node root = new Node(1);
        root.left = new Node(2);
        root.right = new Node(3);
        root.right.left = new Node(4);
        root.right.right = new Node(5);
        root.left.left = new Node(1);

        Console.WriteLine(getMaxSum(root));
    }
}
JavaScript 
// Node Structure
class Node {
    constructor(x) {
        this.data = x;
        this.left = null;
        this.right = null;
    }
}

// method to return the maximum 
// sum rooted at the node 'node'
function getMaxSumUtil(node, memo) {
    if (node === null) return 0;

    if (memo.has(node)) {
        return memo.get(node);
    }

    // Calculate the maximum sum 
    // including the current node
    let include = node.data;

    if (node.left !== null) {
        include += getMaxSumUtil(node.left.left, memo) +
                   getMaxSumUtil(node.left.right, memo);
    }

    if (node.right !== null) {
        include += getMaxSumUtil(node.right.left, memo) +
                   getMaxSumUtil(node.right.right, memo);
    }

    // Calculate the maximum sum 
    // excluding the current node
    let exclude = getMaxSumUtil(node.left, memo) +
                  getMaxSumUtil(node.right, memo);

    memo.set(node, Math.max(include, exclude));
    return memo.get(node);
}

function getMaxSum(root) {
    let memo = new Map();
    return getMaxSumUtil(root, memo);
}

// Create binary tree 
//          1
//         / \
//        2   3
//       /   / \
//      1   4   5
let root = new Node(1);
root.left = new Node(2);
root.right = new Node(3);
root.right.left = new Node(4);
root.right.right = new Node(5);
root.left.left = new Node(1);

console.log(getMaxSum(root));

Output
11

[Expected Approach 2] Using Include-Exclude Strategy

In this approach, we return a list for each node in the binary tree such that the first of the pair indicates the maximum sum when the data of a node is included and the second indicates the maximum sum when the data of a particular node is not included.

C++ 
#include <iostream>
#include <vector>

using namespace std;

// Node Structure
class Node {
public:
    int data;
    Node* left;
    Node* right;
    Node(int x) {
        data = x;
        left = right = NULL;
    }
};

vector<int> maxSumHelper(Node* root) {
    if (root == NULL) return {0, 0}; 

    vector<int> resLeft = maxSumHelper(root->left);
    vector<int> resRight = maxSumHelper(root->right);

    int include = root->data + resLeft[1] + resRight[1];
    int exclude = max(resLeft[0], resLeft[1]) + 
                  max(resRight[0], resRight[1]);

    // returns a vector having 2 values
    // 1st value being max sum when root node is included
    // 2nd value being max sum when root node is excluded
    return {include, exclude};
}

int getMaxSum(Node* root) {
    vector<int> res = maxSumHelper(root);
    
    return max(res[0], res[1]);
}

int main() {
    // Create binary tree
    //          1
    //         / \
    //        2   3
    //       /   / \
    //      1   4   5
    Node* root = new Node(1);
    root->left = new Node(2);
    root->right = new Node(3);
    root->right->left = new Node(4);
    root->right->right = new Node(5);
    root->left->left = new Node(1);

    cout << getMaxSum(root) << endl;
    return 0;
}
Java 
import java.util.ArrayList;
import java.util.Arrays;

// Node Structure
class Node {
    int data;
    Node left, right;
    Node(int data) {
      
        this.data = data;
        left = right = null;
    }
};

class GFG {

    static ArrayList<Integer> maxSumHelper(Node root) {
        if (root == null) {
            return new ArrayList(Arrays.asList(0, 0));
        }

        ArrayList<Integer> resLeft = maxSumHelper(root.left);
        ArrayList<Integer> resRight = maxSumHelper(root.right);

        int include = root.data + resLeft.get(1) + resRight.get(1);

        int exclude = Math.max(resLeft.get(1), resLeft.get(0)) 
                    + Math.max(resRight.get(1), resRight.get(0));

        
        // returns a vector having 2 values
        // 1st value being max sum when root node is included
        // 2nd value being max sum when root node is excluded
        return new ArrayList<>(Arrays.asList(include, exclude));
    }

    static int getMaxSum(Node root) {
        ArrayList<Integer> res = maxSumHelper(root);
        return Math.max(res.get(0), res.get(1));
    }

    public static void main(String args[]) {
      
        // Creating a binary tree
        //          1
        //         / \
        //        2   3
        //       /   / \
        //      1   4   5

        Node root = new Node(1);           
        root.left = new Node(2);             
        root.right = new Node(3);           
        root.right.left = new Node(4);     
        root.right.right = new Node(5);     
        root.left.left = new Node(1);   
      
      	System.out.print(getMaxSum(root));
      
    }
}
Python 
# Node Structure
class Node:
    def __init__(self, x):
        self.data = x
        self.left = None
        self.right = None

def maxSumHelper(root):
    if root is None:
        return [0, 0] 

    resLeft = maxSumHelper(root.left)
    resRight = maxSumHelper(root.right)

    include = root.data + resLeft[1] + resRight[1]
    exclude = max(resLeft[0], resLeft[1]) + \
              max(resRight[0], resRight[1])

    
    # returns a vector having 2 values
    # 1st value being max sum when root node is included
    # 2nd value being max sum when root node is excluded
    return [include, exclude]

def getMaxSum(root):
    res = maxSumHelper(root)
    return max(res[0], res[1])

if __name__ == "__main__":
    # Create binary tree
    #          1
    #         / \
    #        2   3
    #       /   / \
    #      1   4   5
    root = Node(1)
    root.left = Node(2)
    root.right = Node(3)
    root.right.left = Node(4)
    root.right.right = Node(5)
    root.left.left = Node(1)

    print(getMaxSum(root))
C# 
using System;
using System.Collections.Generic;

// Node Structure
class Node {
    public int data;
    public Node left, right;

    public Node(int x) {
        data = x;
        left = right = null;
    }
}

class GFG {

    static List<int> maxSumHelper(Node root) {
        if (root == null) return new List<int>{0, 0};

        List<int> resLeft = maxSumHelper(root.left);
        List<int> resRight = maxSumHelper(root.right);

        int include = root.data + resLeft[1] + resRight[1];
        
        int exclude = Math.Max(resLeft[0], resLeft[1]) + 
                      Math.Max(resRight[0], resRight[1]);

        // returns a vector having 2 values
        // 1st value being max sum when root node is included
        // 2nd value being max sum when root node is excluded
        return new List<int>{include, exclude};
    }

    static int getMaxSum(Node root) {
        List<int> res = maxSumHelper(root);
        return Math.Max(res[0], res[1]);
    }

    static void Main(string[] args) {
        // Create binary tree
        //          1
        //         / \
        //        2   3
        //       /   / \
        //      1   4   5
        
        Node root = new Node(1);
        root.left = new Node(2);
        root.right = new Node(3);
        root.right.left = new Node(4);
        root.right.right = new Node(5);
        root.left.left = new Node(1);

        Console.WriteLine(getMaxSum(root));
    }
}
JavaScript 
// Node Structure
class Node {
    constructor(x) {
        this.data = x;
        this.left = null;
        this.right = null;
    }
}

function maxSumHelper(root) {
    if (root === null) {
        return [0, 0];
    }

    let resLeft = maxSumHelper(root.left);
    let resRight = maxSumHelper(root.right);

    let include = root.data + resLeft[1] + resRight[1];
    
    let exclude = Math.max(resLeft[0], resLeft[1]) + 
                  Math.max(resRight[0], resRight[1]);


    // returns a vector having 2 values
    // 1st value being max sum when root node is included
    // 2nd value being max sum when root node is excluded
    return [include, exclude];
}

function getMaxSum(root) {
    let res = maxSumHelper(root);
    return Math.max(res[0], res[1]);
}

// Driver code

// Create binary tree
//          1
//         / \
//        2   3
//       /   / \
//      1   4   5
let root = new Node(1);
root.left = new Node(2);
root.right = new Node(3);
root.right.left = new Node(4);
root.right.right = new Node(5);
root.left.left = new Node(1);

console.log(getMaxSum(root));

Output
11

Time Complexity: O(n)
Auxiliary Space: O(h), where h is height of binary tree due to recursion stack space

Comment
Article Tags:
Tree
DSA

Explore