# Maximum spiral sum in Binary Tree

Given a binary tree containing n nodes. The problem 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 next level from left to right, then further next level from right to left and so on.

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

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Approach: 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.

## C++

 `// C++ implementation to find maximum spiral sum ` `#include ` ` `  `using` `namespace` `std; ` ` `  `// structure of a node of binary tree ` `struct` `Node { ` `    ``int` `data; ` `    ``Node *left, *right; ` `}; ` ` `  `// A utility function to create a new node ` `Node* newNode(``int` `data) ` `{ ` `    ``// allocate space ` `    ``Node* node = ``new` `Node; ` ` `  `    ``// put in the data ` `    ``node->data = data; ` `    ``node->left = node->right = NULL; ` ` `  `    ``return` `node; ` `} ` ` `  `// function to find the maximum sum contiguous subarray. ` `// implements kadane's algorithm ` `int` `maxSum(vector<``int``> arr, ``int` `n) ` `{ ` `    ``// to store the maximum value that is ending ` `    ``// up to the current index ` `    ``int` `max_ending_here = INT_MIN; ` ` `  `    ``// to store the maximum value encountered so far ` `    ``int` `max_so_far = INT_MIN; ` ` `  `    ``// traverse the array elements ` `    ``for` `(``int` `i = 0; i < n; i++) { ` ` `  `        ``// if max_ending_here < 0, then it could ` `        ``// not possibly contribute to the maximum  ` `        ``// sum further ` `        ``if` `(max_ending_here < 0) ` `            ``max_ending_here = arr[i]; ` ` `  `        ``// else add the value arr[i] to max_ending_here ` `        ``else` `            ``max_ending_here += arr[i]; ` ` `  `        ``// update max_so_far ` `        ``max_so_far = max(max_so_far, max_ending_here); ` `    ``} ` ` `  `    ``// required maxium sum contiguous subarray value ` `    ``return` `max_so_far; ` `} ` ` `  `// function to find maximum spiral sum ` `int` `maxSpiralSum(Node* root) ` `{ ` `    ``// if tree is empty ` `    ``if` `(root == NULL) ` `        ``return` `0; ` ` `  `    ``// Create two stacks to store alternate levels ` `    ``stack s1; ``// For levels from right to left ` `    ``stack s2; ``// For levels from left to right ` ` `  `    ``// vector to store spiral order traversal ` `    ``// of the binary tree ` `    ``vector<``int``> arr; ` ` `  `    ``// Push first level to first stack 's1' ` `    ``s1.push(root); ` ` `  `    ``// traversing tree in spiral form until  ` `    ``// there are elements in any one of the  ` `    ``// stacks ` `    ``while` `(!s1.empty() || !s2.empty()) { ` ` `  `        ``// traverse current level from s1 and ` `        ``// push nodes of next level to s2 ` `        ``while` `(!s1.empty()) { ` `            ``Node* temp = s1.top(); ` `            ``s1.pop(); ` ` `  `            ``// push temp-data to 'arr' ` `            ``arr.push_back(temp->data); ` ` `  `            ``// Note that right is pushed before left ` `            ``if` `(temp->right) ` `                ``s2.push(temp->right); ` `            ``if` `(temp->left) ` `                ``s2.push(temp->left); ` `        ``} ` ` `  `        ``// traverse current level from s2 and ` `        ``// push nodes of next level to s1 ` `        ``while` `(!s2.empty()) { ` `            ``Node* temp = s2.top(); ` `            ``s2.pop(); ` ` `  `            ``// push temp-data to 'arr' ` `            ``arr.push_back(temp->data); ` ` `  `            ``// Note that left is pushed before right ` `            ``if` `(temp->left) ` `                ``s1.push(temp->left); ` `            ``if` `(temp->right) ` `                ``s1.push(temp->right); ` `        ``} ` `    ``} ` ` `  `    ``// required maximum spiral sum ` `    ``return` `maxSum(arr, arr.size()); ` `} ` ` `  `// Driver program to test above ` `int` `main() ` `{ ` `    ``Node* root = newNode(-2); ` `    ``root->left = newNode(-3); ` `    ``root->right = newNode(4); ` `    ``root->left->left = newNode(5); ` `    ``root->left->right = newNode(1); ` `    ``root->right->left = newNode(-2); ` `    ``root->right->right = newNode(-1); ` `    ``root->left->left->left = newNode(-3); ` `    ``root->right->right->right = newNode(2); ` ` `  `    ``cout << ``"Maximum Spiral Sum = "` `         ``<< maxSpiralSum(root); ` ` `  `    ``return` `0; ` `} `

## Java

 `// Java implementation to find maximum spiral sum ` `import` `java.util.ArrayList; ` `import` `java.util.Stack; ` `public` `class` `MaxSpiralSum { ` ` `  `    ``// function to find the maximum sum contiguous subarray.  ` `    ``// implements kadane's algorithm  ` `    ``static` `int` `maxSum(ArrayList arr)  ` `    ``{  ` `        ``// to store the maximum value that is ending  ` `        ``// up to the current index  ` `        ``int` `max_ending_here = Integer.MIN_VALUE;  ` `   `  `        ``// to store the maximum value encountered so far  ` `        ``int` `max_so_far = Integer.MIN_VALUE;  ` `   `  `        ``// traverse the array elements  ` `        ``for` `(``int` `i = ``0``; i < arr.size(); i++)  ` `        ``{          ` `            ``// if max_ending_here < 0, then it could  ` `            ``// not possibly contribute to the maximum   ` `            ``// sum further  ` `            ``if` `(max_ending_here < ``0``)  ` `                ``max_ending_here = arr.get(i);  ` `   `  `            ``// else add the value arr[i] to max_ending_here  ` `            ``else` `                ``max_ending_here +=arr.get(i);  ` `   `  `            ``// update max_so_far  ` `            ``max_so_far = Math.max(max_so_far, max_ending_here);  ` `        ``}  ` `   `  `        ``// required maxium sum contiguous subarray value  ` `        ``return` `max_so_far;  ` `    ``}  ` ` `  `    ``// Function to find maximum spiral sum  ` `    ``public` `static` `int` `maxSpiralSum(Node root)  ` `    ``{   ` `        ``// if tree is empty  ` `        ``if` `(root == ``null``)  ` `            ``return` `0``;  ` `   `  `        ``// Create two stacks to store alternate levels  ` `        ``Stack s1=``new` `Stack<>();``// For levels from right to left  ` `        ``Stack s2=``new` `Stack<>(); ``// For levels from left to right  ` `   `  `        ``// ArrayList to store spiral order traversal  ` `        ``// of the binary tree  ` `        ``ArrayList arr=``new` `ArrayList<>(); ` `   `  `        ``// Push first level to first stack 's1'  ` `        ``s1.push(root);  ` `   `  `        ``// traversing tree in spiral form until   ` `        ``// there are elements in any one of the   ` `        ``// stacks  ` `        ``while` `(!s1.isEmpty() || !s2.isEmpty())  ` `        ``{  ` `   `  `            ``// traverse current level from s1 and  ` `            ``// push nodes of next level to s2  ` `            ``while` `(!s1.isEmpty())  ` `            ``{  ` `                ``Node temp = s1.pop();  ` `   `  `                ``// push temp-data to 'arr'  ` `                ``arr.add(temp.data);  ` `   `  `                ``// Note that right is pushed before left  ` `                ``if` `(temp.right!=``null``)  ` `                    ``s2.push(temp.right);  ` `                ``if` `(temp.left!=``null``)  ` `                    ``s2.push(temp.left);  ` `            ``}  ` `   `  `            ``// traverse current level from s2 and  ` `            ``// push nodes of next level to s1  ` `            ``while` `(!s2.isEmpty())  ` `            ``{  ` `                ``Node temp = s2.pop();  ` `                ``// push temp-data to 'arr'  ` `                ``arr.add(temp.data);  ` `                ``// Note that left is pushed before right  ` `                ``if` `(temp.left!=``null``)  ` `                    ``s1.push(temp.left);  ` `                ``if` `(temp.right!=``null``)  ` `                    ``s1.push(temp.right);  ` `            ``}  ` `        ``}  ` `   `  `        ``// required maximum spiral sum  ` `        ``return` `maxSum(arr);  ` `    ``}  ` ` `  ` `  `    ``public` `static` `void` `main(String args[]) { ` `        ``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.print(``"Maximum Spiral Sum = "``+maxSpiralSum(root)); ` `    ``} ` `} ` ` `  `/* A binary tree node has data, pointer to left child  ` `   ``and a pointer to right child */` `class` `Node  ` `{  ` `    ``int` `data ;  ` `    ``Node  left,  right ;  ` `    ``Node(``int` `data) ` `    ``{ ` `        ``this``.data=data; ` `        ``left=right=``null``; ` `    ``} ` ` `  `};  ` `//This code is contributed by Gaurav Tiwari `

## Python3

 `  `  `# Python3 Implementation to find the maximum Spiral Sum ` ` `  `# Structure of a node in binary tree ` `class` `Node: ` `     `  `    ``def` `__init__(``self``, data): ` `         `  `        ``self``.data ``=` `data ` `        ``self``.left ``=` `None` `        ``self``.right ``=` `None` ` `  `# function to find the maximum sum contiguous subarray ` `# implementing kadane's algorithm ` `def` `maxSum(Arr): ` ` `  `    ``currSum ``=` `maxSum ``=` `0` `    ``for` `element ``in` `Arr: ` `        ``currSum ``=` `max``(currSum ``+` `element, element) ` `        ``maxSum ``=` `max``(maxSum, currSum) ` ` `  `    ``return` `maxSum ` ` `  `# function to find maximum spiral sum  ` `def` `maxSpiralSum(root): ` ` `  `    ``# if tree is empty ` `    ``if` `not` `root: ` `        ``return` `0` ` `  `    ``# create two stacks to stopre alternative levels ` `    ``stack_s1 ``=` `[] ``# from levels right to left ` `    ``stack_s2 ``=` `[] ``# from levels left to right ` ` `  `    ``# store spiral order traversal in Arr ` `    ``Arr ``=` `[] ` `    ``stack_s1.append(root) ` ` `  `    ``# traversing tree in spiral form ` `    ``# until there are elements in any one ` `    ``# of the stack ` `    ``while` `stack_s1 ``or` `stack_s2: ` ` `  `        ``# traverse current level from s1 and ` `        ``# push node of next level to s2  ` `        ``while` `stack_s1: ` `             `  `            ``temp ``=` `stack_s1.pop() ` ` `  `            ``# append temp-> data to Arr ` `            ``Arr.append(temp.data) ` ` `  `            ``if` `temp.right: ` `                ``stack_s2.append(temp.right) ` `            ``if` `temp.left: ` `                ``stack_s2.append(temp.left) ` ` `  `        ``# traverse current level from s2 and ` `        ``# push node of next level to s1 ` `        ``while` `stack_s2: ` `             `  `            ``temp ``=` `stack_s2.pop() ` ` `  `            ``# append temp-> data to Arr ` `            ``Arr.append(temp.data) ` ` `  `            ``if` `temp.left: ` `                ``stack_s1.append(temp.left) ` `            ``if` `temp.right: ` `                ``stack_s1.append(temp.right) ` ` `  `    ``return` `maxSum(Arr)  ` ` `  `# Driver code ` `if` `__name__ ``=``=` `"__main__"``: ` ` `  `    ``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``(``"Maximum Spiral Sum is : "``, maxSpiralSum(root)) ` ` `  `# This code is contributed by ` `# Mayank Chaudhary (chaudhary_19) `

## C#

 `// C# implementation to find maximum spiral sum ` `using` `System; ` `using` `System.Collections.Generic; ` ` `  `public` `class` `MaxSpiralSum  ` `{ ` ` `  `    ``// function to find the maximum ` `    ``// sum contiguous subarray.  ` `    ``// implements kadane's algorithm  ` `    ``static` `int` `maxSum(List<``int``> arr)  ` `    ``{  ` `        ``// to store the maximum value that is ending  ` `        ``// up to the current index  ` `        ``int` `max_ending_here = ``int``.MinValue;  ` `     `  `        ``// to store the maximum value encountered so far  ` `        ``int` `max_so_far = ``int``.MinValue;  ` `     `  `        ``// traverse the array elements  ` `        ``for` `(``int` `i = 0; i < arr.Count; i++)  ` `        ``{          ` `            ``// if max_ending_here < 0, then it could  ` `            ``// not possibly contribute to the maximum  ` `            ``// sum further  ` `            ``if` `(max_ending_here < 0)  ` `                ``max_ending_here = arr[i];  ` `     `  `            ``// else add the value arr[i] ` `            ``// to max_ending_here  ` `            ``else` `                ``max_ending_here +=arr[i];  ` `     `  `            ``// update max_so_far  ` `            ``max_so_far = Math.Max(max_so_far, max_ending_here);  ` `        ``}  ` `     `  `        ``// required maxium sum ` `        ``// contiguous subarray value  ` `        ``return` `max_so_far;  ` `    ``}  ` ` `  `    ``// Function to find maximum spiral sum  ` `    ``public` `static` `int` `maxSpiralSum(Node root)  ` `    ``{  ` `        ``// if tree is empty  ` `        ``if` `(root == ``null``)  ` `            ``return` `0;  ` `     `  `        ``// Create two stacks to store alternate levels  ` `        ``Stack s1 = ``new` `Stack();``// For levels from right to left  ` `        ``Stack s2 = ``new` `Stack(); ``// For levels from left to right  ` `     `  `        ``// ArrayList to store spiral order traversal  ` `        ``// of the binary tree  ` `        ``List<``int``> arr=``new` `List<``int``>(); ` `     `  `        ``// Push first level to first stack 's1'  ` `        ``s1.Push(root);  ` `     `  `        ``// traversing tree in spiral form until  ` `        ``// there are elements in any one of the  ` `        ``// stacks  ` `        ``while` `(s1.Count != 0 || s2.Count != 0)  ` `        ``{  ` `     `  `            ``// traverse current level from s1 and  ` `            ``// push nodes of next level to s2  ` `            ``while` `(s1.Count != 0)  ` `            ``{  ` `                ``Node temp = s1.Pop();  ` `     `  `                ``// push temp-data to 'arr'  ` `                ``arr.Add(temp.data);  ` `     `  `                ``// Note that right is pushed before left  ` `                ``if` `(temp.right != ``null``)  ` `                    ``s2.Push(temp.right);  ` `                ``if` `(temp.left != ``null``)  ` `                    ``s2.Push(temp.left);  ` `            ``}  ` `     `  `            ``// traverse current level from s2 and  ` `            ``// push nodes of next level to s1  ` `            ``while` `(s2.Count != 0)  ` `            ``{  ` `                ``Node temp = s2.Pop();  ` `                 `  `                ``// push temp-data to 'arr'  ` `                ``arr.Add(temp.data); ` `                 `  `                ``// Note that left is pushed before right  ` `                ``if` `(temp.left != ``null``)  ` `                    ``s1.Push(temp.left);  ` `                ``if` `(temp.right != ``null``)  ` `                    ``s1.Push(temp.right);  ` `            ``}  ` `        ``}  ` `     `  `        ``// required maximum spiral sum  ` `        ``return` `maxSum(arr);  ` `    ``}  ` ` `  `    ``// Driver code ` `    ``public` `static` `void` `Main(String []args) ` `    ``{ ` `        ``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.Write(``"Maximum Spiral Sum = "` `+  ` `                      ``maxSpiralSum(root)); ` `    ``} ` `} ` ` `  `/* A binary tree node has data, ` `pointer to left child and ` `a pointer to right child */` `public` `class` `Node  ` `{  ` `    ``public` `int` `data ;  ` `    ``public` `Node left, right ;  ` `    ``public` `Node(``int` `data) ` `    ``{ ` `        ``this``.data = data; ` `        ``left = right = ``null``; ` `    ``} ` ` `  `}; ` ` `  `// This code is contributed Rajput-Ji  `

Output:

```Maximum Spiral Sum = 7
```

Time Complexity: O(n).
Auxiliary Space: O(n).

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

My Personal Notes arrow_drop_up Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.

Article Tags :
Practice Tags :

4

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.