Related Articles
Largest number possible by arranging node values at each level
• Last Updated : 25 Nov, 2020

Given a Binary Tree with positive values at each node, the task is to print the maximum number that can be formed by arranging nodes at each level.

Examples:

```Input:                4
/   \
2    59
/ \   / \
1   3  2  6
Output:
Maximum number at 0'th level is 4
Maximum number at 1'st level is 592
Maximum number at 2'nd level is 6321

Input:           1
/   \
2     3
/ \     \
4   5     8
/  \
6    79
Output:
Explanation :
The maximum number at the 0'th level is 1
The maximum number at 1'st level is 32
The maximum number at 2'nd level is 854
The maximum number at 3'rd level is 796```

Approach:

• Traverse all nodes at each level one by one using Level Order Traversal.
• Store their values in a vector of strings.
• Sort the vector using Comparison method to generate greatest number possible.
• Display the number and repeat the procedure for all levels.

Below code is the implementation of the above approach:

## C++

 `// C++ program to find maximum number``// possible from nodes at each level.``#include ``using` `namespace` `std;` `/* A binary tree node representation */``struct` `Node {``    ``int` `data;``    ``struct` `Node *left, *right;``};` `int` `myCompare(string X, string Y)``{``    ``// first append Y at the end of X``    ``string XY = X.append(Y);` `    ``// then append X at the end of Y``    ``string YX = Y.append(X);` `    ``// Now see which of the two formed numbers is greater``    ``return` `XY.compare(YX) > 0 ? 1 : 0;``}` `// Function to print the largest value``// from the vector of strings``void` `printLargest(vector arr)``{``    ``// Sort the numbers using comparison function``    ``// myCompare() to compare two strings.``    ``// Refer http:// www.cplusplus.com/reference/algorithm/sort/``    ``sort(arr.begin(), arr.end(), myCompare);` `    ``for` `(``int` `i = 0; i < arr.size(); i++)``        ``cout << arr[i];` `    ``cout << ``"\n"``;``}` `// Function to return the maximum number``// possible from nodes at each level``// using level order traversal``int` `maxLevelNumber(``struct` `Node* root)``{``    ``// Base case``    ``if` `(root == NULL)``        ``return` `0;` `    ``// Initialize result``    ``int` `result = root->data;` `    ``// Level Order Traversal``    ``queue q;``    ``q.push(root);` `    ``while` `(!q.empty()) {` `        ``// Get the size of the queue for the level``        ``int` `count = q.size();``        ``vector v;``        ``// Iterate over all the nodes``        ``while` `(count--) {` `            ``// Dequeue nodes from queue``            ``Node* temp = q.front();``            ``q.pop();` `            ``// push that node to vector``            ``v.push_back(to_string(temp->data));``            ``// Push left and right nodes to queue``            ``// if present``            ``if` `(temp->left != NULL)``                ``q.push(temp->left);``            ``if` `(temp->right != NULL)``                ``q.push(temp->right);``        ``}` `        ``// Print the maximum number at that level``        ``printLargest(v);``    ``}` `    ``return` `result;``}` `/* Helper function that allocates a new node with the``given data and NULL left and right pointers. */``struct` `Node* newNode(``int` `data)``{``    ``struct` `Node* node = ``new` `Node;``    ``node->data = data;``    ``node->left = node->right = NULL;``    ``return` `(node);``}` `// Driver code``int` `main()``{``    ``struct` `Node* root = newNode(1);``    ``root->left = newNode(2);``    ``root->right = newNode(3);``    ``root->left->left = newNode(4);``    ``root->left->right = newNode(5);``    ``root->right->right = newNode(8);``    ``root->right->right->left = newNode(6);``    ``root->right->right->right = newNode(7);` `   ``/* Constructed Binary tree is:``            ``1``           ``/ \``          ``2   3``         ``/ \   \``        ``4   5   8``               ``/ \``               ``6 7              */``    ``maxLevelNumber(root);``    ``return` `0;``}`

## Java

 `// Java program to find maximum number``// possible from nodes at each level``import` `java.util.*;``import` `java.lang.*;``import` `java.io.*;` `class` `GFG{` `// Node structure``static` `class` `node``{``    ``int` `data;``    ``node left = ``null``;``    ``node right = ``null``;``}` `// Creates and initilize a new node``static` `node newNode(``int` `ch)``{``    ` `    ``// Allocating memory to a new node``    ``node n = ``new` `node();``    ``n.data = ch;``    ``n.left = ``null``;``    ``n.right = ``null``;``    ``return` `n;``}` `// Function to print the largest value``// from the vector of strings``static` `void` `printLargest(ArrayList arr)``{``    ` `    ``// Sort the numbers using comparison function``    ``// myCompare() to compare two strings.``    ``// Refer http:// www.cplusplus.com/reference/algorithm/sort/``    ``Collections.sort(arr,``new` `Comparator<>()``    ``{``        ``public` `int` `compare(String X, String Y)``        ``{``            ` `            ``// First append Y at the end of X``            ``String XY = X + Y;``            ` `            ``// Then append X at the end of Y``            ``String YX = Y + X;``            ` `            ``// Now see which of the two``            ``// formed numbers is greater``            ``return` `XY.compareTo(YX) > ``0` `? -``1` `: ``1``;``       ``}``    ``});``    ` `    ``for``(``int` `i = ``0``; i < arr.size(); i++)``        ``System.out.print(arr.get(i));``        ` `    ``System.out.println();``}` `// Function to return the maximum number``// possible from nodes at each level``// using level order traversal``static` `int` `maxLevelNumber(node root)``{``    ` `    ``// Base case``    ``if` `(root == ``null``)``        ``return` `0``;``        ` `    ``// Initialize result``    ``int` `result = root.data;` `    ``// Level Order Traversal``    ``Queue q = ``new` `LinkedList<>();``    ``q.add(root);` `    ``while` `(!q.isEmpty())``    ``{``        ` `        ``// Get the size of the queue``        ``// for the level``        ``int` `count = q.size();``        ``ArrayList v = ``new` `ArrayList<>();``        ` `        ``// Iterate over all the nodes``        ``while` `(count-->``0``)``        ``{``            ` `            ``// Dequeue nodes from queue``            ``node temp = q.peek();``            ``q.poll();``            ` `            ``// push that node to vector``            ``v.add(Integer.toString(temp.data));``            ` `            ``// Push left and right nodes to queue``            ``// if present``            ``if` `(temp.left != ``null``)``                ``q.add(temp.left);``            ``if` `(temp.right != ``null``)``                ``q.add(temp.right);``        ``}``        ` `        ``// Print the maximum number at that level``        ``printLargest(v);``    ``}``    ``return` `result;``}` `// Driver code``public` `static` `void` `main (String[] args)``{``    ``node root = newNode(``1``);``    ``root.left = newNode(``2``);``    ``root.right = newNode(``3``);``    ``root.left.left = newNode(``4``);``    ``root.left.right = newNode(``5``);``    ``root.right.right = newNode(``8``);``    ``root.right.right.left = newNode(``6``);``    ``root.right.right.right = newNode(``7``);``    ` `    ``/* Constructed Binary tree is:``            ``1``           ``/ \``          ``2   3``         ``/ \   \``        ``4   5   8``               ``/ \``              ``6   7 */``    ``maxLevelNumber(root);``}``}` `// This code is contributed by offbeat`
Output:
```1
32
854
76```

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