Flatten BST to sorted list | Decreasing order
Last Updated :
10 Nov, 2021
Given a binary search tree, the task is to flatten it to a sorted list in decreasing order. Precisely, the value of each node must be greater than the values of all the nodes at its right, and its left node must be NULL after flattening. We must do it in O(H) extra space where ‘H’ is the height of BST.
Examples:
Input:
5
/ \
3 7
/ \ / \
2 4 6 8
Output: 8 7 6 5 4 3 2
Input:
1
\
2
\
3
\
4
\
5
Output: 5 4 3 2 1
Approach: A simple approach will be to recreate the BST from its ‘reverse in-order’ traversal. This will take O(N) extra space where N is the number of nodes in BST.
To improve upon that, we will simulate the reverse in-order traversal of a binary tree as follows:
- Create a dummy node.
- Create a variable called ‘prev’ and make it point to the dummy node.
- Perform reverse in-order traversal and at each step.
- Set prev -> right = curr
- Set prev -> left = NULL
- Set prev = curr
This will improve the space complexity to O(H) in the worst case as in-order traversal takes O(H) extra space.
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
struct node {
int data;
node* left;
node* right;
node( int data)
{
this ->data = data;
left = NULL;
right = NULL;
}
};
void print(node* parent)
{
node* curr = parent;
while (curr != NULL)
cout << curr->data << " " , curr = curr->right;
}
void revInorder(node* curr, node*& prev)
{
if (curr == NULL)
return ;
revInorder(curr->right, prev);
prev->left = NULL;
prev->right = curr;
prev = curr;
revInorder(curr->left, prev);
}
node* flatten(node* parent)
{
node* dummy = new node(-1);
node* prev = dummy;
revInorder(parent, prev);
prev->left = NULL;
prev->right = NULL;
node* ret = dummy->right;
delete dummy;
return ret;
}
int main()
{
node* root = new node(5);
root->left = new node(3);
root->right = new node(7);
root->left->left = new node(2);
root->left->right = new node(4);
root->right->left = new node(6);
root->right->right = new node(8);
print(flatten(root));
return 0;
}
|
Java
import java.util.*;
class GFG{
static class node
{
int data;
node left;
node right;
node( int data)
{
this .data = data;
left = null ;
right = null ;
}
};
static void print(node parent)
{
node curr = parent;
while (curr != null )
{
System.out.print(curr.data + " " );
curr = curr.right;
}
}
static node prev;
static void revInorder(node curr)
{
if (curr == null )
return ;
revInorder(curr.right);
prev.left = null ;
prev.right = curr;
prev = curr;
revInorder(curr.left);
}
static node flatten(node parent)
{
node dummy = new node(- 1 );
prev = dummy;
revInorder(parent);
prev.left = null ;
prev.right = null ;
node ret = dummy.right;
return ret;
}
public static void main(String[] args)
{
node root = new node( 5 );
root.left = new node( 3 );
root.right = new node( 7 );
root.left.left = new node( 2 );
root.left.right = new node( 4 );
root.right.left = new node( 6 );
root.right.right = new node( 8 );
print(flatten(root));
}
}
|
Python3
class node:
def __init__( self , data):
self .data = data;
self .left = None ;
self .right = None ;
def printNode(parent):
curr = parent;
while (curr ! = None ):
print (curr.data, end = ' ' )
curr = curr.right;
def revInorder(curr):
global prev;
if (curr = = None ):
return ;
revInorder(curr.right);
prev.left = None ;
prev.right = curr;
prev = curr;
revInorder(curr.left);
def flatten(parent):
global prev;
dummy = node( - 1 );
prev = dummy;
revInorder(parent);
prev.left = None ;
prev.right = None ;
ret = dummy.right;
return ret;
prev = node( 0 )
root = node( 5 );
root.left = node( 3 );
root.right = node( 7 );
root.left.left = node( 2 );
root.left.right = node( 4 );
root.right.left = node( 6 );
root.right.right = node( 8 );
printNode(flatten(root));
|
C#
using System;
class GFG{
public class node
{
public int data;
public node left;
public node right;
public node( int data)
{
this .data = data;
left = null ;
right = null ;
}
};
static void print(node parent)
{
node curr = parent;
while (curr != null )
{
Console.Write(curr.data + " " );
curr = curr.right;
}
}
static node prev;
static void revInorder(node curr)
{
if (curr == null )
return ;
revInorder(curr.right);
prev.left = null ;
prev.right = curr;
prev = curr;
revInorder(curr.left);
}
static node flatten(node parent)
{
node dummy = new node(-1);
prev = dummy;
revInorder(parent);
prev.left = null ;
prev.right = null ;
node ret = dummy.right;
return ret;
}
public static void Main(String[] args)
{
node root = new node(5);
root.left = new node(3);
root.right = new node(7);
root.left.left = new node(2);
root.left.right = new node(4);
root.right.left = new node(6);
root.right.right = new node(8);
print(flatten(root));
}
}
|
Javascript
<script>
class node
{
constructor(data)
{
this .left = null ;
this .right = null ;
this .data = data;
}
}
function print(parent)
{
let curr = parent;
while (curr != null )
{
document.write(curr.data + " " );
curr = curr.right;
}
}
let prev;
function revInorder(curr)
{
if (curr == null )
return ;
revInorder(curr.right);
prev.left = null ;
prev.right = curr;
prev = curr;
revInorder(curr.left);
}
function flatten(parent)
{
let dummy = new node(-1);
prev = dummy;
revInorder(parent);
prev.left = null ;
prev.right = null ;
let ret = dummy.right;
return ret;
}
let root = new node(5);
root.left = new node(3);
root.right = new node(7);
root.left.left = new node(2);
root.left.right = new node(4);
root.right.left = new node(6);
root.right.right = new node(8);
print(flatten(root));
</script>
|
Time Complexity: O(N)
Auxiliary Space: O(N)
Like Article
Suggest improvement
Share your thoughts in the comments
Please Login to comment...