Convert a Binary Search Tree into a Skewed tree in increasing or decreasing order
Given a Binary Search Tree and a binary integer K, the task is to convert Binary search tree into a Skewed Tree in increasing order if K = 0 or in decreasing order if K = 1.
Examples:
Input: K = 0,
5
/ \
3 6
Output:
3
\
5
\
6
Input: K = 1,
2
/ \
1 3
Output:
3
\
2
\
1
Approach:
- The key observation in the problem is that the first node of the skewed tree will be the extreme left or extreme right node of the BST for increasing order and decreasing order respectively.
- For Increasing Order we need to do the Inorder Traversal, as the inorder traversal of a BST provides us the increasing sequence of the node values. Hence, the order of traversal at every node will be:
- Left node: Recurse to its left node if it exists, to get smaller value.
- Root node: After the complete traversal of its left node/subtree, connect the previous node of the skewed tree to the root node.
- Right node: Recurse to the right node if it exists, for larger values.
- For Decreasing Order, the order of traversal at every node will be:
- Right node: Recurse to its right node if it exists, to get larger values.
- Root node: After the complete traversal of its right node/subtree, connect the previous node of the skewed tree to the root node.
- Left node: Recurse to the left node/subtree for smaller values.
- Similarly, by keeping track of the previous node we can traverse the Binary search tree according to the order needed and form the skewed tree.
Below is the implementation of the above approach:
C++14
#include<bits/stdc++.h>
using namespace std;
struct Node
{
int val;
Node *left, *right;
Node( int x)
{
val = x;
left = right = NULL;
}
};
Node *prevNode = NULL;
Node *headNode = NULL;
void flattenBTToSkewed(Node *root, int order)
{
if (!root)
return ;
if (order)
flattenBTToSkewed(root->right, order);
else
flattenBTToSkewed(root->left, order);
Node *rightNode = root->right;
Node *leftNode = root->left;
if (!headNode)
{
headNode = root;
root->left = NULL;
prevNode = root;
}
else
{
prevNode->right = root;
root->left = NULL;
prevNode = root;
}
if (order)
flattenBTToSkewed(leftNode, order);
else
flattenBTToSkewed(rightNode, order);
}
void traverseRightSkewed(Node *root)
{
if (!root)
return ;
cout << root->val << " " ;
traverseRightSkewed(root->right);
}
int main()
{
Node *root = new Node(5);
root->left = new Node(3);
root->right = new Node(6);
int order = 0;
flattenBTToSkewed(root, order);
traverseRightSkewed(headNode);
}
|
Java
import java.io.*;
class Node
{
int val;
Node left, right;
Node( int item)
{
val = item;
left = right = null ;
}
}
class GFG
{
public static Node node;
static Node prevNode = null ;
static Node headNode = null ;
static void flattenBTToSkewed(Node root,
int order)
{
if (root == null )
{
return ;
}
if (order > 0 )
{
flattenBTToSkewed(root.right, order);
}
else
{
flattenBTToSkewed(root.left, order);
}
Node rightNode = root.right;
Node leftNode = root.left;
if (headNode == null )
{
headNode = root;
root.left = null ;
prevNode = root;
}
else
{
prevNode.right = root;
root.left = null ;
prevNode = root;
}
if (order > 0 )
{
flattenBTToSkewed(leftNode, order);
}
else
{
flattenBTToSkewed(rightNode, order);
}
}
static void traverseRightSkewed(Node root)
{
if (root == null )
{
return ;
}
System.out.print(root.val + " " );
traverseRightSkewed(root.right);
}
public static void main (String[] args)
{
GFG tree = new GFG();
tree.node = new Node( 5 );
tree.node.left = new Node( 3 );
tree.node.right = new Node( 6 );
int order = 0 ;
flattenBTToSkewed(node, order);
traverseRightSkewed(headNode);
}
}
|
Python3
class Node:
def __init__( self , val):
self .val = val
self .left = None
self .right = None
prevNode = None
headNode = None
def flattenBTToSkewed(root, order):
if not root:
return
if order:
flattenBTToSkewed(root.right, order)
else :
flattenBTToSkewed(root.left, order)
global headNode; global prevNode
rightNode = root.right
leftNode = root.left
if not headNode:
headNode = root
root.left = None
prevNode = root
else :
prevNode.right = root
root.left = None
prevNode = root
if order:
flattenBTToSkewed(leftNode, order)
else :
flattenBTToSkewed(rightNode, order)
def traverseRightSkewed(root):
if not root:
return
print (root.val, end = " " )
traverseRightSkewed(root.right)
if __name__ = = "__main__" :
root = Node( 5 )
root.left = Node( 3 )
root.right = Node( 6 )
prevNode = None
headNode = None
order = 0
flattenBTToSkewed(root, order)
traverseRightSkewed(headNode)
|
C#
using System;
class Node
{
public int val;
public Node left, right;
public Node( int item)
{
val = item;
left = right = null ;
}
}
class GFG{
public static Node node;
static Node prevNode = null ;
static Node headNode = null ;
static void flattenBTToSkewed(Node root, int order)
{
if (root == null )
{
return ;
}
if (order > 0)
{
flattenBTToSkewed(root.right, order);
}
else
{
flattenBTToSkewed(root.left, order);
}
Node rightNode = root.right;
Node leftNode = root.left;
if (headNode == null )
{
headNode = root;
root.left = null ;
prevNode = root;
}
else
{
prevNode.right = root;
root.left = null ;
prevNode = root;
}
if (order > 0)
{
flattenBTToSkewed(leftNode, order);
}
else
{
flattenBTToSkewed(rightNode, order);
}
}
static void traverseRightSkewed(Node root)
{
if (root == null )
{
return ;
}
Console.Write(root.val + " " );
traverseRightSkewed(root.right);
}
static public void Main()
{
GFG.node = new Node(5);
GFG.node.left = new Node(3);
GFG.node.right = new Node(6);
int order = 0;
flattenBTToSkewed(node, order);
traverseRightSkewed(headNode);
}
}
|
Javascript
<script>
class Node
{
constructor(item)
{
this .val = item;
this .left = this .right = null ;
}
}
let node;
let prevNode = null ;
let headNode = null ;
function flattenBTToSkewed(root,order)
{
if (root == null )
{
return ;
}
if (order > 0)
{
flattenBTToSkewed(root.right, order);
}
else
{
flattenBTToSkewed(root.left, order);
}
let rightNode = root.right;
let leftNode = root.left;
if (headNode == null )
{
headNode = root;
root.left = null ;
prevNode = root;
}
else
{
prevNode.right = root;
root.left = null ;
prevNode = root;
}
if (order > 0)
{
flattenBTToSkewed(leftNode, order);
}
else
{
flattenBTToSkewed(rightNode, order);
}
}
function traverseRightSkewed(root)
{
if (root == null )
{
return ;
}
document.write(root.val + " " );
traverseRightSkewed(root.right);
}
node = new Node(5);
node.left = new Node(3);
node.right = new Node(6);
let order = 0;
flattenBTToSkewed(node, order);
traverseRightSkewed(headNode);
</script>
|
Time Complexity: O(n), where n is the number of nodes in the binary search tree.
Auxiliary Space: O(h), where h is the height of the binary search tree.
Last Updated :
03 Apr, 2023
Like Article
Save Article
Share your thoughts in the comments
Please Login to comment...