Skip to content
Related Articles

Related Articles

Flatten BST to sorted list | Decreasing order
  • Last Updated : 02 Nov, 2020

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:  

  1. Create a dummy node.
  2. Create a variable called ‘prev’ and make it point to the dummy node.
  3. 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++




// C++ implementation of the
// above approach
#include <bits/stdc++.h>
using namespace std;
 
// Node of the binary tree
struct node {
    int data;
    node* left;
    node* right;
    node(int data)
    {
        this->data = data;
        left = NULL;
        right = NULL;
    }
};
 
// Function to print flattened
// binary tree
void print(node* parent)
{
    node* curr = parent;
    while (curr != NULL)
        cout << curr->data << " ", curr = curr->right;
}
 
// Function to perform reverse in-order traversal
void revInorder(node* curr, node*& prev)
{
    // Base case
    if (curr == NULL)
        return;
    revInorder(curr->right, prev);
    prev->left = NULL;
    prev->right = curr;
    prev = curr;
    revInorder(curr->left, prev);
}
 
// Function to flatten binary tree using
// level order traversal
node* flatten(node* parent)
{
 
    // Dummy node
    node* dummy = new node(-1);
 
    // Pointer to previous element
    node* prev = dummy;
 
    // Calling in-order traversal
    revInorder(parent, prev);
 
    prev->left = NULL;
    prev->right = NULL;
    node* ret = dummy->right;
 
    // Delete dummy node
    delete dummy;
    return ret;
}
 
// Driver code
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);
 
    // Calling required function
    print(flatten(root));
 
    return 0;
}

Java




// Java implementation of the
// above approach
import java.util.*;
class GFG{
 
// Node of the binary tree
static class node
{
  int data;
  node left;
  node right;
   
  node(int data)
  {
    this.data = data;
    left = null;
    right = null;
  }
};
 
// Function to print flattened
// binary tree
static void print(node parent)
{
  node curr = parent;
  while (curr != null)
  {
    System.out.print(curr.data + " ");
    curr = curr.right;
  }
}
 
static  node prev;
   
// Function to perform reverse
// in-order traversal
static void revInorder(node curr)
{
  // Base case
  if (curr == null)
    return;
  revInorder(curr.right);
  prev.left = null;
  prev.right = curr;
  prev = curr;
  revInorder(curr.left);
}
 
// Function to flatten binary
// tree using level order
// traversal
static node flatten(node parent)
{
  // Dummy node
  node dummy = new node(-1);
 
  // Pointer to previous
  // element
  prev = dummy;
 
  // Calling in-order
  // traversal
  revInorder(parent);
 
  prev.left = null;
  prev.right = null;
  node ret = dummy.right;
 
  // Delete dummy node
  //delete dummy;
  return ret;
}
 
// Driver code
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);
 
  // Calling required function
  print(flatten(root));
}
}
 
// This code is contributed by Amit Katiyar

C#




// C# implementation of the
// above approach
using System;
 
class GFG{
 
// Node of the binary tree
public class node
{
  public int data;
  public node left;
  public node right;
   
  public node(int data)
  {
    this.data = data;
    left = null;
    right = null;
  }
};
 
// Function to print flattened
// binary tree
static void print(node parent)
{
  node curr = parent;
   
  while (curr != null)
  {
    Console.Write(curr.data + " ");
    curr = curr.right;
  }
}
 
static  node prev;
   
// Function to perform reverse
// in-order traversal
static void revInorder(node curr)
{
   
  // Base case
  if (curr == null)
    return;
   
  revInorder(curr.right);
  prev.left = null;
  prev.right = curr;
  prev = curr;
   
  revInorder(curr.left);
}
 
// Function to flatten binary
// tree using level order
// traversal
static node flatten(node parent)
{
   
  // Dummy node
  node dummy = new node(-1);
 
  // Pointer to previous
  // element
  prev = dummy;
 
  // Calling in-order
  // traversal
  revInorder(parent);
 
  prev.left = null;
  prev.right = null;
  node ret = dummy.right;
   
  // Delete dummy node
  //delete dummy;
  return ret;
}
 
// Driver code
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);
 
  // Calling required function
  print(flatten(root));
}
}
 
// This code is contributed by Rajput-Ji
Output: 
8 7 6 5 4 3 2






 

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 industry experts, please refer Geeks Classes Live and Geeks Classes Live USA

My Personal Notes arrow_drop_up
Recommended Articles
Page :