Skip to content
Related Articles

Related Articles

Improve Article

Convert a Binary Tree to BST by left shifting digits of node values

  • Difficulty Level : Medium
  • Last Updated : 18 Jun, 2021

Given a Binary Tree of positive integers. The task is to convert it to a BST using left shift operations on the digits of the nodes. If it is not possible to convert the binary tree to BST then print -1.

Examples:

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.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

Input:                      443 
                              /        \  
                          132      543 
                                    /      \ 
                                343     237



Output:                   344 
                               /        \ 
                         132       435 
                                   /        \ 
                               433       723

Explanation:   443 → left shift two times → 344 
                         132 → zero shift operations → 132 
                         543 → left shift one time → 435 
                         343 → left shift one time → 433 
                         237 → left shift two times → 723

Input:                    43 
                         /        \ 
                      56         45

Output: -1

Approach: The idea is to perform Inorder traversal on the Binary Tree in increasing order because in-order traversal of a BST always generates sorted sequence. Follow the steps below to solve the problem:

  • Initialize a variable, say prev = -1, to keep track of the value of the previous node.
  • Then, traverse the tree using Inorder Traversal and try to convert every node to its lowest possible value greater than the previous value by left shifting its digits.
  • After performing these operations, check if the binary tree is a BST or not.
  • If found to be true, print the tree. Otherwise, print -1.

Below is the implementation of the above approach:

C++




// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;
 
// Structure of a Node
struct TreeNode
{
   int val;
   TreeNode *left, *right;
 
    TreeNode(int key)
    {
        val = key;
        left = NULL;
        right = NULL;
    }
};
 
// Function to check if
// the tree is BST or not
bool isBST(TreeNode *root, TreeNode *l = NULL, TreeNode *r = NULL)
{
 
    // Base condition
    if (!root)
        return true;
 
    // Check for left child
    if (l && root->val <= l->val)
        return false;
 
    // Check for right child
    if (r && root->val >= r->val)
        return false;
 
    // Check for left and right subtrees
    return isBST(root->left, l, root) and isBST(root->right, root, r);
}
 
// Function to convert a tree to BST
// by left shift of its digits
void ConvTree(TreeNode *root,int &prev)
{
 
    // If root is NULL
    if (!root)
        return;
 
    // Recursively modify the
    // left subtree
    ConvTree(root->left,prev);
 
    // Initialise optimal element
    // to the initial element
    int optEle = root->val;
 
    // Convert it into a string
    string strEle = to_string(root->val);
 
    // For checking all the
    // left shift operations
    bool flag = true;
    for (int idx = 0; idx < strEle.size(); idx++)
    {
 
        // Perform left shift
        int shiftedNum = stoi(strEle.substr(idx) + strEle.substr(0, idx));
 
        // If the number after left shift
        // is the minimum and greater than
        // its previous element
 
        // first value >= prev
 
        // used to setup initialize optEle
        // cout<<prev<<endl;
        if (shiftedNum >= prev and flag)
        {
            optEle = shiftedNum;
            flag = false;
          }
 
        if (shiftedNum >= prev)
            optEle = min(optEle, shiftedNum);
      }
    root->val = optEle;
    prev = root->val;
   
    // Recursively solve for right
    // subtree
    ConvTree(root->right,prev);
}
 
// Function to print level
// order traversal of a tree
void levelOrder(TreeNode *root)
{
    queue<TreeNode*> que;
    que.push(root);
    while(true)
    {
        int length = que.size();
        if (length == 0)
            break;
        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;
        }
   
        // new line
        cout << endl;
}
 
// Driver Code
int main()
{
 
  TreeNode *root = new TreeNode(443);
  root->left = new TreeNode(132);
  root->right = new TreeNode(543);
  root->right->left = new TreeNode(343);
  root->right->right = new TreeNode(237);
 
  // Converts the tree to BST
  int prev = -1;
  ConvTree(root, prev);
 
  // If tree is converted to a BST
  if (isBST(root, NULL, NULL))
  {
      // Print its level order traversal
      levelOrder(root);
    }
  else
  {
     
      // not possible
      cout << (-1);
    }
}
 
// This code is contributed by mohit kumar 29

Java




// Java program for the above approach
import java.util.*;
 
class GFG{
     
static int prev;
 
// Structure of a Node
static class TreeNode
{
    int val;
    TreeNode left, right;
     
    TreeNode(int key)
    {
        val = key;
        left = null;
        right = null;
    }
};
 
// Function to check if
// the tree is BST or not
static boolean isBST(TreeNode root, TreeNode l,
                     TreeNode r)
{
     
    // Base condition
    if (root == null)
        return true;
 
    // Check for left child
    if (l != null && root.val <= l.val)
        return false;
 
    // Check for right child
    if (r != null && root.val >= r.val)
        return false;
 
    // Check for left and right subtrees
    return isBST(root.left, l, root) &
           isBST(root.right, root, r);
}
 
// Function to convert a tree to BST
// by left shift of its digits
static void ConvTree(TreeNode root)
{
     
    // If root is null
    if (root == null)
        return;
         
    // Recursively modify the
    // left subtree
    ConvTree(root.left);
 
    // Initialise optimal element
    // to the initial element
    int optEle = root.val;
 
    // Convert it into a String
    String strEle = String.valueOf(root.val);
 
    // For checking all the
    // left shift operations
    boolean flag = true;
     
    for(int idx = 0; idx < strEle.length(); idx++)
    {
         
        // Perform left shift
        int shiftedNum = Integer.parseInt(
            strEle.substring(idx) +
            strEle.substring(0, idx));
 
        // If the number after left shift
        // is the minimum and greater than
        // its previous element
 
        // first value >= prev
 
        // used to setup initialize optEle
        // System.out.print(prev<<endl;
        if (shiftedNum >= prev && flag)
        {
            optEle = shiftedNum;
            flag = false;
        }
         
        if (shiftedNum >= prev)
            optEle = Math.min(optEle, shiftedNum);
    }
    root.val = optEle;
    prev = root.val;
   
    // Recursively solve for right
    // subtree
    ConvTree(root.right);
}
 
// Function to print level
// order traversal of a tree
static void levelOrder(TreeNode root)
{
    Queue<TreeNode> que = new LinkedList<GFG.TreeNode>();
    que.add(root);
     
    while(true)
    {
        int length = que.size();
         
        if (length == 0)
            break;
             
        while (length > 0)
        {
            TreeNode temp = que.peek();
            que.remove();
            System.out.print(temp.val + " ");
             
            if (temp.left != null)
                que.add(temp.left);
            if (temp.right != null)
                que.add(temp.right);
                 
            length -= 1;
        }
        System.out.println();
    }
     
    // New line
    System.out.println();
}
 
// Driver Code
public static void main(String[] args)
{
    TreeNode root = new TreeNode(443);
    root.left = new TreeNode(132);
    root.right = new TreeNode(543);
    root.right.left = new TreeNode(343);
    root.right.right = new TreeNode(237);
     
    // Converts the tree to BST
    prev = -1;
    ConvTree(root);
     
    // If tree is converted to a BST
    if (isBST(root, null, null))
    {
         
        // Print its level order traversal
        levelOrder(root);
    }
    else
    {
         
        // not possible
        System.out.print(-1);
    }
}
}
 
// This code is contributed by shikhasingrajput

Python3




# Python3 program for the above approach
 
# Structure of a Node
class TreeNode:
    def __init__(self, key):
        self.val = key
        self.left = None
        self.right = None
 
# Function to check if
# the tree is BST or not
def isBST(root, l = None, r = None):
 
    # Base condition
    if not root:
        return True
 
    # Check for left child
    if l and root.val <= l.val:
        return False
 
    # Check for right child
    if r and root.val >= r.val:
        return False
 
    # Check for left and right subtrees
    return isBST(root.left, l, root) and isBST(root.right, root, r)
 
# Function to convert a tree to BST
# by left shift of its digits
def ConvTree(root):
    global prev
 
    # If root is NULL
    if not root:
        return
 
    # Recursively modify the
    # left subtree
    ConvTree(root.left)
 
    # Initialise optimal element
    # to the initial element
    optEle = root.val
 
    # Convert it into a string
    strEle = str(root.val)
 
    # For checking all the
    # left shift operations
    flag = True
 
    for idx in range(len(strEle)):
 
        # Perform left shift
        shiftedNum = int(strEle[idx:] + strEle[:idx])
 
        # If the number after left shift
        # is the minimum and greater than
        # its previous element
 
        # first value >= prev
 
        # used to setup initialize optEle
        if shiftedNum >= prev and flag:
            optEle = shiftedNum
            flag = False
 
        if shiftedNum >= prev:
            optEle = min(optEle, shiftedNum)
 
    root.val = optEle
    prev = root.val
    # Recursively solve for right
    # subtree
    ConvTree(root.right)
 
# Function to print level
# order traversal of a tree
def levelOrder(root):
    que = [root]
    while True:
        length = len(que)
        if not length:
            break
 
        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
        # new line
        print()
 
# Driver Code
 
root = TreeNode(443)
root.left = TreeNode(132)
root.right = TreeNode(543)
root.right.left = TreeNode(343)
root.right.right = TreeNode(237)
 
# Initialize to
# previous element
prev = -1
 
# Converts the tree to BST
ConvTree(root)
 
# If tree is converted to a BST
if isBST(root, None, None):
 
    # Print its level order traversal
    levelOrder(root)
else:
    # not possible
    print(-1)

C#




// C# program for the above approach
using System;
using System.Collections.Generic;
class GFG
{
     
static int prev;
 
// Structure of a Node
class TreeNode
{
    public int val;
    public TreeNode left, right; 
    public TreeNode(int key)
    {
        val = key;
        left = null;
        right = null;
    }
};
 
// Function to check if
// the tree is BST or not
static bool isBST(TreeNode root, TreeNode l,
                     TreeNode r)
{
     
    // Base condition
    if (root == null)
        return true;
 
    // Check for left child
    if (l != null && root.val <= l.val)
        return false;
 
    // Check for right child
    if (r != null && root.val >= r.val)
        return false;
 
    // Check for left and right subtrees
    return isBST(root.left, l, root) &
           isBST(root.right, root, r);
}
 
// Function to convert a tree to BST
// by left shift of its digits
static void ConvTree(TreeNode root)
{
     
    // If root is null
    if (root == null)
        return;
         
    // Recursively modify the
    // left subtree
    ConvTree(root.left);
 
    // Initialise optimal element
    // to the initial element
    int optEle = root.val;
 
    // Convert it into a String
    String strEle = String.Join("", root.val);
 
    // For checking all the
    // left shift operations
    bool flag = true;
     
    for(int idx = 0; idx < strEle.Length; idx++)
    {
         
        // Perform left shift
        int shiftedNum = Int32.Parse(
            strEle.Substring(idx) +
            strEle.Substring(0, idx));
 
        // If the number after left shift
        // is the minimum and greater than
        // its previous element
 
        // first value >= prev
 
        // used to setup initialize optEle
        // Console.Write(prev<<endl;
        if (shiftedNum >= prev && flag)
        {
            optEle = shiftedNum;
            flag = false;
        }
         
        if (shiftedNum >= prev)
            optEle = Math.Min(optEle, shiftedNum);
    }
    root.val = optEle;
    prev = root.val;
   
    // Recursively solve for right
    // subtree
    ConvTree(root.right);
}
 
// Function to print level
// order traversal of a tree
static void levelOrder(TreeNode root)
{
    Queue<TreeNode> que = new Queue<GFG.TreeNode>();
    que.Enqueue(root);
     
    while(true)
    {
        int length = que.Count;
        if (length == 0)
            break;     
        while (length > 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);       
            length -= 1;
        }
        Console.WriteLine();
    }
     
    // New line
    Console.WriteLine();
}
 
// Driver Code
public static void Main(String[] args)
{
    TreeNode root = new TreeNode(443);
    root.left = new TreeNode(132);
    root.right = new TreeNode(543);
    root.right.left = new TreeNode(343);
    root.right.right = new TreeNode(237);
     
    // Converts the tree to BST
    prev = -1;
    ConvTree(root);
     
    // If tree is converted to a BST
    if (isBST(root, null, null))
    {
         
        // Print its level order traversal
        levelOrder(root);
    }
    else
    {
         
        // not possible
        Console.Write(-1);
    }
}
}
  
// This code is contributed by shikhasingrajput

Javascript




<script>
 
  // JavaScript program for the above approach
   
  let prev;
  
  // Structure of a Node
  class TreeNode
  {
      constructor(key) {
         this.left = null;
         this.right = null;
         this.val = key;
      }
  }
   
  // Function to check if
  // the tree is BST or not
  function isBST(root, l, r)
  {
        
      // Base condition
      if (root == null)
          return true;
    
      // Check for left child
      if (l != null && root.val <= l.val)
          return false;
    
      // Check for right child
      if (r != null && root.val >= r.val)
          return false;
    
      // Check for left and right subtrees
      return isBST(root.left, l, root) &
             isBST(root.right, root, r);
  }
    
  // Function to convert a tree to BST
  // by left shift of its digits
  function ConvTree(root)
  {
        
      // If root is null
      if (root == null)
          return;
            
      // Recursively modify the
      // left subtree
      ConvTree(root.left);
    
      // Initialise optimal element
      // to the initial element
      let optEle = root.val;
    
      // Convert it into a String
      let strEle = (root.val).toString();
    
      // For checking all the
      // left shift operations
      let flag = true;
        
      for(let idx = 0; idx < strEle.length; idx++)
      {
            
          // Perform left shift
          let shiftedNum = parseInt(
              strEle.substring(idx) +
              strEle.substring(0, idx));
    
          // If the number after left shift
          // is the minimum and greater than
          // its previous element
    
          // first value >= prev
    
          // used to setup initialize optEle
          // Console.Write(prev<<endl;
          if (shiftedNum >= prev && flag)
          {
              optEle = shiftedNum;
              flag = false;
          }
            
          if (shiftedNum >= prev)
              optEle = Math.min(optEle, shiftedNum);
      }
      root.val = optEle;
      prev = root.val;
      
      // Recursively solve for right
      // subtree
      ConvTree(root.right);
  }
    
  // Function to print level
  // order traversal of a tree
  function levelOrder(root)
  {
      let que = [];
      que.push(root);
        
      while(true)
      {
          let length = que.length;
          if (length == 0)
              break;    
          while (length > 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);      
              length -= 1;
          }
          document.write("</br>");
      }
        
      // New line
      document.write("</br>");
  }
   
  let root = new TreeNode(443);
  root.left = new TreeNode(132);
  root.right = new TreeNode(543);
  root.right.left = new TreeNode(343);
  root.right.right = new TreeNode(237);
    
  // Converts the tree to BST
  prev = -1;
  ConvTree(root);
    
  // If tree is converted to a BST
  if (isBST(root, null, null))
  {
        
      // Print its level order traversal
      levelOrder(root);
  }
  else
  {
        
      // not possible
      document.write(-1);
  }
     
</script>
Output: 
344 
132 435 
433 723

 

Time Complexity: O(N)
Auxiliary Space: O(N)




My Personal Notes arrow_drop_up
Recommended Articles
Page :