📜  按升序左旋转二叉树各级节点值的数字

📅  最后修改于: 2021-10-26 02:30:00             🧑  作者: Mango

给定一个二叉树,任务是通过向左旋转每个节点任意次数来修改树,这样每个级别都由从左到右递增的节点值组成。如果无法按升序排列任何级别的节点值,则打印“-1”

例子:

方法:给定的问题可以通过执行 Level Order Traversal 并左旋节点值的数字来解决给定的问题,以使每个级别的值按升序排列。请按照以下步骤解决问题:

  • 初始化一个队列,比如说Q ,用于执行层序遍历。
  • 将树的根节点推入队列。
  • 迭代直到队列不为空并执行以下步骤:
    • 找到队列的大小并将其存储在变量L 中
    • 初始化一个变量,比如prev ,用于存储树的当前级别中的前一个元素。
    • 迭代范围[0, L]并执行以下步骤:
      • 弹出队列的前端节点并将其存储在一个变量中,比如temp
      • 现在,左移元素temp ,如果存在任何大于prev 且更接近prev 的排列,则将当前节点的值更新为temp的值。
    • prev的值更新为temp的当前值。
    • 如果temp有左孩子或右孩子,则将其推入队列。
  • 经过上述步骤后,如果当前节点集没有按升序排列,则打印“No” 。否则,检查下一次迭代。

下面是上述方法的实现:

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


Java
// 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 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 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 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
# 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


Javascript


输出:
134 
124 231 
243 352 611

时间复杂度: O(N)
辅助空间: O(N)

如果您希望与专家一起参加现场课程,请参阅DSA 现场工作专业课程学生竞争性编程现场课程