Flatten BST to sorted list | Decreasing order

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 variable called ‘prev’ and make it point to 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:

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ implementation of the 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;
}

chevron_right


Output:

8 7 6 5 4 3 2


My Personal Notes arrow_drop_up

Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.