Maximum spiral sum in Binary Tree

Last Updated : 22 Oct, 2024

Given a binary tree containing n nodes. The task is to find the maximum sum obtained when the tree is spirally traversed. In spiral traversal one by one all levels are being traversed with the root level traversed from right to left, then the next level from left to right, then further next level from right to left and so on.

Example: 

Input:

maximum-spiral-sum-in-binary-tree-1

Output: 7
Explanation: Maximum spiral sum = 4 + (-1) + (-2) + 1 + 5 = 7

7

Approach:

The idea is to obtain the level order traversal in spiral form of the given binary tree with the help of two stacks and store it in an array. Find the maximum sum sub-array of the array so obtained.

Below is the implementation of the above approach:

C++ 
// C++ program to maximum 
// spiral sum in Binary Tree
#include <bits/stdc++.h>
using namespace std;

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

int spiralSum (Node* root) {
    if (root == nullptr) return 0;
    
    stack<Node*> currentLevel, nextLevel;
    currentLevel.push(root);
    
    // variable to indicate direction 
    // of traversal.
    bool leftToRight = false;
    
    // Array to store spiral traversal.
    vector<int> arr;
    
    while (!currentLevel.empty()) {
        
        int size = currentLevel.size();
        while (size--) {
            Node* curr = currentLevel.top();
            currentLevel.pop();
            arr.push_back(curr->data);
            
            // if current direction to lor, then
            // push left node first, so that next 
            // level traversal is rol.
            if (leftToRight) {
                if (curr->left != nullptr) 
                    nextLevel.push(curr->left);
                if (curr->right != nullptr)
                    nextLevel.push(curr->right);
            }
            else {
                if (curr->right != nullptr)
                    nextLevel.push(curr->right);
                if (curr->left != nullptr) 
                    nextLevel.push(curr->left);
            }
        }
        
        // Flip the direction.
        leftToRight = !leftToRight;
        
        // Swap the stacks.
        swap(currentLevel, nextLevel);
    }
    
    int ans = INT_MIN;
    
    // variable to store the sum of current subarray.
    int prev = 0;
    
    // Performing kadane's algorithm
    for (int i = 0; i<arr.size(); i++) {
        
        // If the current subarray sum is less than
        // 0, then start a new subarrray from
        // index i.
        if (prev<0) prev = 0;
        
        // include the current value into 
        // the subarray sum.
        prev += arr[i];
        
        // Compare the current subarray sum 
        // with the maximum subarray sum.
        ans = max(ans, prev);
    }
    
    return ans;
}

int main() {
    
    // Binary tree
    //          -2
    //        /    \
    //      -3      4
    //     /  \    / \
    //   5    1  -2   -1
    //   /             \
    // -3               2
    Node* root = new Node(-2);
    root->left = new Node(-3);
    root->right = new Node(4);
    root->left->left = new Node(5);
    root->left->right = new Node(1);
    root->right->left = new Node(-2);
    root->right->right = new Node(-1);
    root->left->left->left = new Node(-3);
    root->right->right->right = new Node(2);
    
    cout << spiralSum(root) << endl;
    return 0;
}
Java 
// Java program to maximum 
// spiral sum in Binary Tree
import java.util.ArrayList;
import java.util.Stack;

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

class GfG {

    static int spiralSum(Node root) {
        if (root == null) return 0;

        Stack<Node> currentLevel = new Stack<>();
        Stack<Node> nextLevel = new Stack<>();
        currentLevel.push(root);

        // variable to indicate direction 
        // of traversal.
        boolean leftToRight = false;

        // Array to store spiral traversal.
        ArrayList<Integer> arr = new ArrayList<>();

        while (!currentLevel.isEmpty()) {
            int size = currentLevel.size();
            while (size-- > 0) {
                Node curr = currentLevel.pop();
                arr.add(curr.data);

                // if current direction to lor, then
                // push left node first, so that next 
                // level traversal is rol.
                if (leftToRight) {
                    if (curr.left != null) 
                        nextLevel.push(curr.left);
                    if (curr.right != null)
                        nextLevel.push(curr.right);
                } else {
                    if (curr.right != null)
                        nextLevel.push(curr.right);
                    if (curr.left != null) 
                        nextLevel.push(curr.left);
                }
            }

            // Flip the direction.
            leftToRight = !leftToRight;

            // Swap the stacks.
            Stack<Node> temp = currentLevel;
            currentLevel = nextLevel;
            nextLevel = temp;
        }

        int ans = Integer.MIN_VALUE;

        // variable to store the sum of current subarray.
        int prev = 0;

        // Performing kadane's algorithm
        for (int i = 0; i < arr.size(); i++) {
            // If the current subarray sum is less than
            // 0, then start a new subarray from
            // index i.
            if (prev < 0) prev = 0;

            // include the current value into 
            // the subarray sum.
            prev += arr.get(i);

            // Compare the current subarray sum 
            // with the maximum subarray sum.
            ans = Math.max(ans, prev);
        }

        return ans;
    }

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

        System.out.println(spiralSum(root));
    }
}
Python 
# Python program to maximum 
# spiral sum in Binary Tree

class Node:
    def __init__(self, x):
        self.data = x
        self.left = None
        self.right = None

def spiralSum(root):
    if root is None:
        return 0

    currentLevel = [root]
    nextLevel = []

    # variable to indicate direction 
    # of traversal.
    leftToRight = False

    # Array to store spiral traversal.
    arr = []

    while currentLevel:
        size = len(currentLevel)
        while size > 0:
            size -= 1
            curr = currentLevel.pop()
            arr.append(curr.data)

            # if current direction to lor, then
            # push left node first, so that next 
            # level traversal is rol.
            if leftToRight:
                if curr.left:
                    nextLevel.append(curr.left)
                if curr.right:
                    nextLevel.append(curr.right)
            else:
                if curr.right:
                    nextLevel.append(curr.right)
                if curr.left:
                    nextLevel.append(curr.left)

        # Flip the direction.
        leftToRight = not leftToRight

        # Swap the lists.
        currentLevel, nextLevel = nextLevel, currentLevel

    ans = float('-inf')

    # variable to store the sum of current 
    # subarray.
    prev = 0

    # Performing kadane's algorithm
    for i in arr:
        
        # If the current subarray sum is less than
        # 0, then start a new subarray from
        # index i.
        if prev < 0:
            prev = 0

        # include the current value into 
        # the subarray sum.
        prev += i

        # Compare the current subarray sum 
        # with the maximum subarray sum.
        ans = max(ans, prev)

    return ans

if __name__ == "__main__":

    # Binary tree
    #          -2
    #        /    \
    #      -3      4
    #     /  \    / \
    #   5    1  -2   -1
    #   /             \
    # -3               2
    root = Node(-2)
    root.left = Node(-3)
    root.right = Node(4)
    root.left.left = Node(5)
    root.left.right = Node(1)
    root.right.left = Node(-2)
    root.right.right = Node(-1)
    root.left.left.left = Node(-3)
    root.right.right.right = Node(2)

print(spiralSum(root))
C# 
// C# program to maximum 
// spiral sum in Binary Tree
using System;
using System.Collections.Generic;

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

class GfG {

    static int spiralSum(Node root) {
        if (root == null) return 0;

        Stack<Node> currentLevel = new Stack<Node>();
        Stack<Node> nextLevel = new Stack<Node>();
        currentLevel.Push(root);

        // variable to indicate direction 
        // of traversal.
        bool leftToRight = false;

        // List to store spiral traversal.
        List<int> arr = new List<int>();

        while (currentLevel.Count > 0) {
            int size = currentLevel.Count;
            while (size-- > 0) {
                Node curr = currentLevel.Pop();
                arr.Add(curr.data);

                // if current direction to lor, then
                // push left node first, so that next 
                // level traversal is rol.
                if (leftToRight) {
                    if (curr.left != null) 
                        nextLevel.Push(curr.left);
                    if (curr.right != null)
                        nextLevel.Push(curr.right);
                } else {
                    if (curr.right != null)
                        nextLevel.Push(curr.right);
                    if (curr.left != null) 
                        nextLevel.Push(curr.left);
                }
            }

            // Flip the direction.
            leftToRight = !leftToRight;

            // Swap the stacks.
            var temp = currentLevel;
            currentLevel = nextLevel;
            nextLevel = temp;
        }

        int ans = int.MinValue;

        // variable to store the sum of 
      	// current subarray.
        int prev = 0;

        // Performing kadane's algorithm
        for (int i = 0; i < arr.Count; i++) {
            
            // If the current subarray sum is less than
            // 0, then start a new subarray from
            // index i.
            if (prev < 0) prev = 0;

            // include the current value into 
            // the subarray sum.
            prev += arr[i];

            // Compare the current subarray sum 
            // with the maximum subarray sum.
            ans = Math.Max(ans, prev);
        }

        return ans;
    }

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

        Console.WriteLine(spiralSum(root));
    }
}
JavaScript 
// JavaScript program to maximum 
// spiral sum in Binary Tree

class Node {
    constructor(x) {
        this.data = x;
        this.left = null;
        this.right = null;
    }
}

function spiralSum(root) {
    if (root === null) return 0;

    let currentLevel = [];
    let nextLevel = [];
    currentLevel.push(root);

    // variable to indicate direction 
    // of traversal.
    let leftToRight = false;

    // Array to store spiral traversal.
    let arr = [];

    while (currentLevel.length > 0) {
        let size = currentLevel.length;
        while (size-- > 0) {
            let curr = currentLevel.pop();
            arr.push(curr.data);

            // if current direction to lor, then
            // push left node first, so that next 
            // level traversal is rol.
            if (leftToRight) {
                if (curr.left !== null)
                    nextLevel.push(curr.left);
                if (curr.right !== null)
                    nextLevel.push(curr.right);
            } else {
                if (curr.right !== null)
                    nextLevel.push(curr.right);
                if (curr.left !== null)
                    nextLevel.push(curr.left);
            }
        }

        // Flip the direction.
        leftToRight = !leftToRight;

        // Swap the arrays.
        let temp = currentLevel;
        currentLevel = nextLevel;
        nextLevel = temp;
    }

    let ans = Number.MIN_SAFE_INTEGER;

    // variable to store the sum of
    // current subarray.
    let prev = 0;

    // Performing kadane's algorithm
    for (let i = 0; i < arr.length; i++) {
        
        // If the current subarray sum is less than
        // 0, then start a new subarray from
        // index i.
        if (prev < 0) prev = 0;

        // include the current value into 
        // the subarray sum.
        prev += arr[i];

        // Compare the current subarray sum 
        // with the maximum subarray sum.
        ans = Math.max(ans, prev);
    }

    return ans;
}

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

console.log(spiralSum(root));

Output
7

Time Complexity: O(n), where n is the number of nodes in the tree.
Auxiliary Space: O(n).

Comment
Article Tags:
Tree
DSA

Explore