# 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 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 ` `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`

## Python3

 `# Python3 implementation of the ` `# above approach`   `# Node of the binary tree` `class` `node:` `    `  `    ``def` `__init__(``self``, data):` `        ``self``.data ``=` `data;` `        ``self``.left ``=` `None``;` `        ``self``.right ``=` `None``;`   `# Function to print flattened` `# binary tree` `def` `printNode(parent):` `    ``curr ``=` `parent;` `    ``while` `(curr !``=` `None``):` `        ``print``(curr.data, end ``=` `' '``)` `        ``curr ``=` `curr.right;`     `# Function to perform reverse in-order traversal` `def` `revInorder(curr):` `    ``global` `prev;` `    ``# Base case` `    ``if` `(curr ``=``=` `None``):` `        ``return``;` `    ``revInorder(curr.right);` `    ``prev.left ``=` `None``;` `    ``prev.right ``=` `curr;` `    ``prev ``=` `curr;` `    ``revInorder(curr.left);`   `# Function to flatten binary tree using` `# level order traversal` `def` `flatten(parent):` `    `  `    ``global` `prev;` `    ``# Dummy node` `    ``dummy ``=` `node(``-``1``);`   `    ``# Pointer to previous element` `    ``prev ``=` `dummy;`   `    ``# Calling in-order traversal` `    ``revInorder(parent);`   `    ``prev.left ``=` `None``;` `    ``prev.right ``=` `None``;` `    ``ret ``=` `dummy.right;`   `    ``return` `ret;`   `# Driver code` `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``);`   `# Calling required function` `printNode(flatten(root));`   `# This code is contributed by rrrtnx.`

## 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`

## Javascript

 ``

Output:

`8 7 6 5 4 3 2`

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

Feeling lost in the world of random DSA topics, wasting time without progress? It's time for a change! Join our DSA course, where we'll guide you on an exciting journey to master DSA efficiently and on schedule.
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 geeks!

Previous
Next