在给定二叉树的情况下，任务是通过左旋转每个节点任意次数多次来修改树，以使每个级别由节点值组成，并从左到右以递增的顺序排列。如果无法按升序排列任何级别的节点值，则打印“ -1” 。
例子：
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
方法：可以通过执行“级别顺序遍历”并左旋转节点值的数字以使每个级别的值按升序排列来解决给定的问题。请按照以下步骤解决问题：
- 初始化一个队列(例如Q) ，该队列用于执行级别顺序遍历。
- 将树的根节点推送到队列中。
- 迭代直到队列不为空，然后执行以下步骤：
- 找到队列的大小并将其存储在变量L中。
- 初始化一个变量，例如prev ，该变量用于将前一个元素存储在树的当前级别中。
- 迭代范围[0，L]并执行以下步骤：
- 弹出队列的前节点，并将其存储在变量中，例如temp 。
- 现在，将元素temp左移，如果存在任何大于prev且更接近prev的置换，则将当前节点的值更新为temp的值。
- 将prev的值更新为temp的当前值。
- 如果温度是左孩子还是右孩子，则将其推入队列。
- 完成上述步骤后，如果当前节点集尚未按升序排序，请打印“否” 。否则，请检查下一个迭代。
下面是上述方法的实现：
C++
// C++ program for the above approach
#include
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 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 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 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 Python3
# 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#
// 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 que = new Queue();
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 que = new Queue();
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 que = new Queue();
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 输出：
134
124 231
243 352 611时间复杂度： O(N)
辅助空间： O(N)