Left rotate digits of node values of all levels of a Binary Tree in increasing order
Last Updated :
01 Aug, 2022
Given a Binary Tree, the task is to modify the Tree by left rotating every node any number of times such that every level consists of node values in increasing order from left to right. If it is not possible to arrange node values of any level in increasing order, then print "-1".
Examples:
Input:
341
/ \
241 123
/ \ \
324 235 161
Output:
341
/ \
124 231
/ \ \
243 352 611
Explanation:
Level 1: The value of the root node is 341, having all digits sorted.
Level 2: The node values are 241 and 123. Left rotating 241 twice and 231 once modifies the node values to 124 and 231.
Level 3: The node values are 342, 235 and 161. Left rotating digits of 342 once, 235 once and 161 once modifies the node values to {243, 352, 611} respectively.
Input:
12
/ \
89 15
Output: -1
Approach: The given problem can be solved by performing Level Order Traversal and left rotating the digits of node values to make values every level in increasing order. Follow the steps below to solve the problem:
- Initialize a queue, say Q that is used to perform the level order traversal.
- Push the root node of the tree in the queue.
- Iterate until the queue is not empty and perform the following steps:
- Find the size of the queue and store it in variable L.
- Initialize a variable, say prev that is used to store the previous element in the current level of the tree.
- Iterate over the range [0, L] and perform the following steps:
- Pop the front node of the queue and store it in a variable, say temp.
- Now, left shift the element temp and if there exists any permutation which is greater than prev and closer to prev then update the current node's value as the value of the temp.
- Update the value of prev to the current value of temp.
- If the temp has left or right child then push it into the queue.
- After the above steps, if the current set of nodes has not ordered in increasing order, then print "No". Otherwise, check for the next iteration.
Below is the implementation of the above approach:
C++
// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;
// TreeNode class
struct TreeNode
{
int val;
TreeNode* left,*right;
TreeNode(int v)
{
val = v;
left = NULL;
right = NULL;
}
};
// Function to check if the nodes
// are in increasing order or not
bool isInc(TreeNode *root)
{
// Perform Level Order Traversal
queue<TreeNode*> que;
que.push(root);
while (true)
{
// Current length of queue
int length = que.size();
// If queue is empty
if (length == 0)
break;
auto pre = que.front();
// Level order traversal
while (length > 0)
{
// Pop element from
// front of the queue
auto temp = que.front();
que.pop();
// If previous value exceeds
// current value, return false
if (pre->val > temp->val)
return false;
pre = temp;
if (temp->left)
que.push(temp->left);
if (temp->right)
que.push(temp->right);
length -= 1;
}
}
return true;
}
// Function to print the Tree
// after modification
void levelOrder(TreeNode *root)
{
// Performs level
// order traversal
queue<TreeNode*> que;
que.push(root);
while (true)
{
// Calculate size of the queue
int length = que.size();
if (length == 0)
break;
// Iterate until queue is empty
while (length)
{
auto temp = que.front();
que.pop();
cout << temp->val << " ";
if (temp->left)
que.push(temp->left);
if (temp->right)
que.push(temp->right);
length -= 1;
}
cout << endl;
}
cout << endl;
}
// Function to arrange node values
// of each level in increasing order
void makeInc(TreeNode *root)
{
// Perform level order traversal
queue<TreeNode*> que;
que.push(root);
while (true)
{
// Calculate length of queue
int length = que.size();
// If queue is empty
if (length == 0)
break;
int prev = -1;
// Level order traversal
while (length > 0)
{
//cout<<"loop";
// Pop element from
// front of the queue
auto temp = que.front();
que.pop();
// Initialize the optimal
// element by the initial
// element
auto optEle = temp->val;
auto strEle = to_string(temp->val);
// Check for all left
// shift operations
bool flag = true;
int yy = strEle.size();
for(int idx = 0; idx < strEle.size(); idx++)
{
// Left shift
int ls = stoi(strEle.substr(idx, yy) +
strEle.substr(0, idx));
if (ls >= prev and flag)
{
optEle = ls;
flag = false;
}
// If the current shifting
// gives optimal solution
if (ls >= prev)
optEle = min(optEle, ls);
}
// Replacing initial element
// by the optimal element
temp->val = optEle;
prev = temp->val;
// Push the LST
if (temp->left)
que.push(temp->left);
// Push the RST
if (temp->right)
que.push(temp->right);
length -= 1;
}
}
// Print the result
if (isInc(root))
levelOrder(root);
else
cout << (-1);
}
// Driver Code
int main()
{
TreeNode *root = new TreeNode(341);
root->left = new TreeNode(241);
root->right = new TreeNode(123);
root->left->left = new TreeNode(324);
root->left->right = new TreeNode(235);
root->right->right = new TreeNode(161);
makeInc(root);
}
// This code is contributed by mohit kumar 29
// Java program for the above approach
import java.util.*;
class GFG{
// TreeNode class
static class TreeNode
{
public int val;
public TreeNode left,right;
};
static TreeNode newNode(int v)
{
TreeNode temp = new TreeNode();
temp.val = v;
temp.left = temp.right = null;
return temp;
}
// Function to check if the nodes
// are in increasing order or not
static boolean isInc(TreeNode root)
{
// Perform Level Order Traversal
Queue<TreeNode> que = new LinkedList<>();
que.add(root);
while (true)
{
// Current len of queue
int len = que.size();
// If queue is empty
if (len == 0)
break;
TreeNode pre = que.peek();
// Level order traversal
while (len > 0)
{
// Pop element from
// front of the queue
TreeNode temp = que.peek();
que.poll();
// If previous value exceeds
// current value, return false
if (pre.val > temp.val)
return false;
pre = temp;
if (temp.left != null)
que.add(temp.left);
if (temp.right != null)
que.add(temp.right);
len -= 1;
}
}
return true;
}
// Function to print the Tree
// after modification
static void levelOrder(TreeNode root)
{
// Performs level
// order traversal
Queue<TreeNode> que = new LinkedList<>();
que.add(root);
while (true)
{
// Calculate size of the queue
int len = que.size();
if (len == 0)
break;
// Iterate until queue is empty
while (len > 0)
{
TreeNode temp = que.peek();
que.poll();
System.out.print(temp.val+" ");
if (temp.left != null)
que.add(temp.left);
if (temp.right != null)
que.add(temp.right);
len -= 1;
}
System.out.println();
}
System.out.println();
}
// Function to arrange node values
// of each level in increasing order
static void makeInc(TreeNode root)
{
// Perform level order traversal
Queue<TreeNode> que = new LinkedList<>();
que.add(root);
while (true)
{
// Calculate len of queue
int len = que.size();
// If queue is empty
if (len == 0)
break;
int prev = -1;
// Level order traversal
while (len > 0)
{
//cout<<"loop";
// Pop element from
// front of the queue
TreeNode temp = que.peek();
que.poll();
// Initialize the optimal
// element by the initial
// element
int optEle = temp.val;
String strEle = String.valueOf(optEle);
// Check for all left
// shift operations
boolean flag = true;
int yy = strEle.length();
for(int idx = 0; idx < strEle.length(); idx++)
{
// Left shift
String s1 = strEle.substring(idx, yy);
String s2 = strEle.substring(0, idx);
String s = s1+ s2;
int ls = Integer.valueOf(s);
if (ls >= prev && flag)
{
optEle = ls;
flag = false;
}
// If the current shifting
// gives optimal solution
if (ls >= prev)
optEle = Math.min(optEle, ls);
}
// Replacing initial element
// by the optimal element
temp.val = optEle;
prev = temp.val;
// Push the LST
if (temp.left != null)
que.add(temp.left);
// Push the RST
if (temp.right != null)
que.add(temp.right);
len -= 1;
}
}
// Print the result
if (isInc(root) == true)
levelOrder(root);
else
System.out.print(-1);
}
// Driver code
public static void main (String[] args)
{
TreeNode root = newNode(341);
root.left = newNode(241);
root.right = newNode(123);
root.left.left = newNode(324);
root.left.right = newNode(235);
root.right.right = newNode(161);
makeInc(root);
}
}
// This code is contributed by offbeat
# Python3 program for the above approach
# TreeNode class
class TreeNode:
def __init__(self, val = 0, left = None, right = None):
self.val = val
self.left = left
self.right = right
# Function to check if the nodes
# are in increasing order or not
def isInc(root):
# Perform Level Order Traversal
que = [root]
while True:
# Current length of queue
length = len(que)
# If queue is empty
if not length:
break
pre = que[0]
# Level order traversal
while length:
# Pop element from
# front of the queue
temp = que.pop(0)
# If previous value exceeds
# current value, return false
if pre.val > temp.val:
return False
pre = temp
if temp.left:
que.append(temp.left)
if temp.right:
que.append(temp.right)
length -= 1
return True
# Function to arrange node values
# of each level in increasing order
def makeInc(root):
# Perform level order traversal
que = [root]
while True:
# Calculate length of queue
length = len(que)
# If queue is empty
if not length:
break
prev = -1
# Level order traversal
while length:
# Pop element from
# front of the queue
temp = que.pop(0)
# Initialize the optimal
# element by the initial
# element
optEle = temp.val
strEle = str(temp.val)
# Check for all left
# shift operations
flag = True
for idx in range(len(strEle)):
# Left shift
ls = int(strEle[idx:] + strEle[:idx])
if ls >= prev and flag:
optEle = ls
flag = False
# If the current shifting
# gives optimal solution
if ls >= prev:
optEle = min(optEle, ls)
# Replacing initial element
# by the optimal element
temp.val = optEle
prev = temp.val
# Push the LST
if temp.left:
que.append(temp.left)
# Push the RST
if temp.right:
que.append(temp.right)
length -= 1
# Print the result
if isInc(root):
levelOrder(root)
else:
print(-1)
# Function to print the Tree
# after modification
def levelOrder(root):
# Performs level
# order traversal
que = [root]
while True:
# Calculate size of the queue
length = len(que)
if not length:
break
# Iterate until queue is empty
while length:
temp = que.pop(0)
print(temp.val, end =' ')
if temp.left:
que.append(temp.left)
if temp.right:
que.append(temp.right)
length -= 1
print()
# Driver Code
root = TreeNode(341)
root.left = TreeNode(241)
root.right = TreeNode(123)
root.left.left = TreeNode(324)
root.left.right = TreeNode(235)
root.right.right = TreeNode(161)
makeInc(root)
// C# program for the above approach
using System;
using System.Collections.Generic;
class GFG{
// TreeNode class
class TreeNode
{
public int val;
public TreeNode left,right;
};
static TreeNode newNode(int v)
{
TreeNode temp = new TreeNode();
temp.val = v;
temp.left = temp.right = null;
return temp;
}
// Function to check if the nodes
// are in increasing order or not
static bool isInc(TreeNode root)
{
// Perform Level Order Traversal
Queue<TreeNode> que = new Queue<TreeNode>();
que.Enqueue(root);
while (true)
{
// Current len of queue
int len = que.Count;
// If queue is empty
if (len == 0)
break;
TreeNode pre = que.Peek();
// Level order traversal
while (len > 0)
{
// Pop element from
// front of the queue
TreeNode temp = que.Peek();
que.Dequeue();
// If previous value exceeds
// current value, return false
if (pre.val > temp.val)
return false;
pre = temp;
if (temp.left != null)
que.Enqueue(temp.left);
if (temp.right != null)
que.Enqueue(temp.right);
len -= 1;
}
}
return true;
}
// Function to print the Tree
// after modification
static void levelOrder(TreeNode root)
{
// Performs level
// order traversal
Queue<TreeNode> que = new Queue<TreeNode>();
que.Enqueue(root);
while (true)
{
// Calculate size of the queue
int len = que.Count;
if (len == 0)
break;
// Iterate until queue is empty
while (len > 0)
{
TreeNode temp = que.Peek();
que.Dequeue();
Console.Write(temp.val+" ");
if (temp.left != null)
que.Enqueue(temp.left);
if (temp.right != null)
que.Enqueue(temp.right);
len -= 1;
}
Console.Write("\n");
}
Console.Write("\n");
}
// Function to arrange node values
// of each level in increasing order
static void makeInc(TreeNode root)
{
// Perform level order traversal
Queue<TreeNode> que = new Queue<TreeNode>();
que.Enqueue(root);
while (true)
{
// Calculate len of queue
int len = que.Count;
// If queue is empty
if (len == 0)
break;
int prev = -1;
// Level order traversal
while (len > 0)
{
//cout<<"loop";
// Pop element from
// front of the queue
TreeNode temp = que.Peek();
que.Dequeue();
// Initialize the optimal
// element by the initial
// element
int optEle = temp.val;
string strEle = optEle.ToString();
// Check for all left
// shift operations
bool flag = true;
int yy = strEle.Length;
for(int idx = 0; idx < strEle.Length; idx++)
{
// Left shift
string s1 = strEle.Substring(idx, yy - idx);
string s2 = strEle.Substring(0, idx);
string s = String.Concat(s1, s2);
int ls = Int32.Parse(s);
if (ls >= prev && flag)
{
optEle = ls;
flag = false;
}
// If the current shifting
// gives optimal solution
if (ls >= prev)
optEle = Math.Min(optEle, ls);
}
// Replacing initial element
// by the optimal element
temp.val = optEle;
prev = temp.val;
// Push the LST
if (temp.left != null)
que.Enqueue(temp.left);
// Push the RST
if (temp.right != null)
que.Enqueue(temp.right);
len -= 1;
}
}
// Print the result
if (isInc(root) == true)
levelOrder(root);
else
Console.Write(-1);
}
// Driver Code
public static void Main()
{
TreeNode root = newNode(341);
root.left = newNode(241);
root.right = newNode(123);
root.left.left = newNode(324);
root.left.right = newNode(235);
root.right.right = newNode(161);
makeInc(root);
}
}
// This code is contributed by ipg2016107
<script>
// Javascript program for the above approach
// TreeNode class
class Node
{
constructor(v)
{
this.val=v;
this.left=this.right=null;
}
}
// Function to check if the nodes
// are in increasing order or not
function isInc(root)
{
// Perform Level Order Traversal
let que = [];
que.push(root);
while (true)
{
// Current len of queue
let len = que.length;
// If queue is empty
if (len == 0)
break;
let pre = que[0];
// Level order traversal
while (len > 0)
{
// Pop element from
// front of the queue
let temp = que[0];
que.shift();
// If previous value exceeds
// current value, return false
if (pre.val > temp.val)
return false;
pre = temp;
if (temp.left != null)
que.push(temp.left);
if (temp.right != null)
que.push(temp.right);
len -= 1;
}
}
return true;
}
// Function to print the Tree
// after modification
function levelOrder(root)
{
// Performs level
// order traversal
let que = [];
que.push(root);
while (true)
{
// Calculate size of the queue
let len = que.length;
if (len == 0)
break;
// Iterate until queue is empty
while (len > 0)
{
let temp = que[0];
que.shift();
document.write(temp.val+" ");
if (temp.left != null)
que.push(temp.left);
if (temp.right != null)
que.push(temp.right);
len -= 1;
}
document.write("<br>");
}
document.write("<br>");
}
// Function to arrange node values
// of each level in increasing order
function makeInc(root)
{
// Perform level order traversal
let que = [];
que.push(root);
while (true)
{
// Calculate len of queue
let len = que.length;
// If queue is empty
if (len == 0)
break;
let prev = -1;
// Level order traversal
while (len > 0)
{
//cout<<"loop";
// Pop element from
// front of the queue
let temp = que[0];
que.shift();
// Initialize the optimal
// element by the initial
// element
let optEle = temp.val;
let strEle = (optEle).toString();
// Check for all left
// shift operations
let flag = true;
let yy = strEle.length;
for(let idx = 0; idx < strEle.length; idx++)
{
// Left shift
let s1 = strEle.substring(idx, yy);
let s2 = strEle.substring(0, idx);
let s = s1+ s2;
let ls = parseInt(s);
if (ls >= prev && flag)
{
optEle = ls;
flag = false;
}
// If the current shifting
// gives optimal solution
if (ls >= prev)
optEle = Math.min(optEle, ls);
}
// Replacing initial element
// by the optimal element
temp.val = optEle;
prev = temp.val;
// Push the LST
if (temp.left != null)
que.push(temp.left);
// Push the RST
if (temp.right != null)
que.push(temp.right);
len -= 1;
}
}
// Print the result
if (isInc(root) == true)
levelOrder(root);
else
document.write(-1);
}
// Driver code
let root = new Node(341);
root.left = new Node(241);
root.right = new Node(123);
root.left.left = new Node(324);
root.left.right = new Node(235);
root.right.right = new Node(161);
makeInc(root);
// This code is contributed by patel2127
</script>
Output: 134
124 231
243 352 611
Time Complexity: O(N)
Auxiliary Space: O(N)
Similar Reads
Count levels in a Binary Tree consisting of node values having set bits at different positions
Given a Binary Tree consisting of N nodes, the task is to count the number of levels in a Binary Tree such that the set bits of all the node values at the same level is at different positions. Examples: Input: 5 / \ 6 9 / \ \ 1 4 7 Output: 2 Explanation: Level 1 has only 5 (= (101)2). Level 2 has 6
10 min read
Check if a Binary Tree contains node values in strictly increasing and decreasing order at even and odd levels
Given a Binary Tree, the task is to check if it consists of node values arranged in strictly increasing order at even levels and strictly decreasing at odd levels (Assuming the root node to be at level 0). Examples: Input: 2 / \ 6 3 / \ \ 4 7 11 / \ \ 10 5 1 Output: YES Explanation: At level 1 (odd)
10 min read
Sum of decimal equivalents of binary node values in each level of a Binary Tree
Given a Binary Tree consisting of nodes with values 0 and 1 only, the task is to find the total sum of the decimal equivalents of the binary numbers formed by connecting nodes at the same level from left to right, on each level. Examples: Input: Below is the given Tree: 0 / \ 1 0 / \ / \ 0 1 1 1Outp
15 min read
Count levels in a Binary Tree consisting of nodes valued 1 grouped together
Given a Binary Tree consisting of 0s and 1s only, the task is to print the count of levels in the Binary Tree in which all the 1s are placed consecutively in a single group. Examples: Input: 0 / \ 1 0 / \ / \ 1 0 1 0 Output: 2 Explanation: In Levels 1 and 2, all the nodes with value 1 are placed con
10 min read
Count paths in a Binary Tree consisting of nodes in non-decreasing order
Given a Binary Tree consisting of N nodes, the task is to find the number of paths from the root to any node X, such that all the node values in that path are at most X. Examples: Input: Below is the given Tree: Output: 4Explanation: The paths from the root to any node X that have value at most valu
15 min read
Print odd positioned nodes of odd levels in level order of the given binary tree
Given a binary tree, the task is to print the odd positioned nodes of odd levels in the level order traversal of the tree. The root is considered at level 0, and the leftmost node of any level is considered as a node at position 0.Example: Input: 1 / \ 2 3 / \ / \ 4 5 6 7 / \ 8 9 / \ 10 11 Output: 3
8 min read
Print odd positioned nodes of even levels in level order of the given binary tree
Given a binary tree, the task is to print the odd positioned nodes of even levels in the level order traversal of the tree. The root is considered at level 0, and the leftmost node of any level is considered as a node at position 0.Example: Input: 1 / \ 2 3 / \ / \ 4 5 6 7 / \ 8 9 / \ 10 11 Output:
8 min read
Sum of Bitwise AND of the sum of all leaf and non-leaf nodes for each level of a Binary Tree
Given a Binary Tree consisting of N nodes, the task is to find the sum of Bitwise AND of the sum of all leaf nodes and the sum of all non-leaf nodes for each level in the given Tree. Examples: Input: Below is the given tree: 5 / \ 3 9 / \ 6 4 \ 7Output: 5Explanation: For Level 1: leaf node sum = 0,
10 min read
Sum of nodes in the left view of the given binary tree
Given a binary tree, the task is to find the sum of the nodes which are visible in the left view. The left view of a binary tree is the set of nodes visible when the tree is viewed from the left.Examples: Example 1 : The Green colored nodes represents the left view in the below Binary tree. The Left
13 min read
Maximum sum of non-leaf nodes among all levels of the given binary tree
Given a Binary Tree having positive and negative nodes, the task is to find the maximum sum of non-leaf nodes among all levels of the given binary tree. Examples: Input: 4 / \ 2 -5 / \ -1 3 Output: 4 Sum of all non-leaf nodes at 0th level is 4. Sum of all non-leaf nodes at 1st level is 2. Sum of all
8 min read