# Flatten binary tree in order of post-order traversal

Given a binary tree, the task is to flatten it in order of its post-order traversal. In the flattened binary tree, the left node of all the nodes must be NULL.

Examples:

```Input:
5
/   \
3     7
/ \   / \
2   4 6   8
Output: 2 4 3 6 8 7 5

Input:
1
\
2
\
3
\
4
\
5
Output: 5 4 3 2 1```

A simple approach will be to recreate the Binary Tree from its post-order traversal. This will take O(N) extra space were N is the number of nodes in BST.

A better solution is to simulate post-order traversal of the given binary tree.

1. Create a dummy node.
2. Create variable called ‘prev’ and make it point to the dummy node.
3. Perform post-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 post-order traversal takes O(H) extra space.

Below is the implementation of the above approach:

## C++

 `// C++ implementation of the 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 the flattened` `// binary Tree` `void` `print(node* parent)` `{` `    ``node* curr = parent;` `    ``while` `(curr != NULL)` `        ``cout << curr->data << ``" "``, curr = curr->right;` `}`   `// Function to perform post-order traversal` `// recursively` `void` `postorder(node* curr, node*& prev)` `{` `    ``// Base case` `    ``if` `(curr == NULL)` `        ``return``;` `    ``postorder(curr->left, prev);` `    ``postorder(curr->right, prev);` `    ``prev->left = NULL;` `    ``prev->right = curr;` `    ``prev = curr;` `}`   `// Function to flatten the given binary tree` `// using post order traversal` `node* flatten(node* parent)` `{` `    ``// Dummy node` `    ``node* dummy = ``new` `node(-1);`   `    ``// Pointer to previous element` `    ``node* prev = dummy;`   `    ``// Calling post-order traversal` `    ``postorder(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);`   `    ``print(flatten(root));`   `    ``return` `0;` `}`

## Java

 `// Java implementation of the approach` `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``;` `    ``}` `};` `static` `node prev;`   `// Function to print the flattened` `// binary Tree` `static` `void` `print(node parent)` `{` `    ``node curr = parent;` `    ``while` `(curr != ``null``)` `    ``{` `        ``System.out.print(curr.data + ``" "``);` `        ``curr = curr.right;` `    ``}` `}`   `// Function to perform post-order traversal` `// recursively` `static` `void` `postorder(node curr)` `{` `    ``// Base case` `    ``if` `(curr == ``null``)` `        ``return``;` `    ``postorder(curr.left);` `    ``postorder(curr.right);` `    ``prev.left = ``null``;` `    ``prev.right = curr;` `    ``prev = curr;` `}`   `// Function to flatten the given binary tree` `// using post order traversal` `static` `node flatten(node parent)` `{` `    ``// Dummy node` `    ``node dummy = ``new` `node(-``1``);`   `    ``// Pointer to previous element` `    ``prev = dummy;`   `    ``// Calling post-order traversal` `    ``postorder(parent);`   `    ``prev.left = ``null``;` `    ``prev.right = ``null``;` `    ``node ret = dummy.right;`   `    ``// Delete dummy node` `    ``dummy = ``null``;` `    ``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``);`   `    ``print(flatten(root));` `}` `} `   `// This code is contributed by PrinciRaj1992`

## Python3

 `# Python implementation of above algorithm`   `# Utility class to create a node ` `class` `node: ` `    ``def` `__init__(``self``, key): ` `        ``self``.data ``=` `key ` `        ``self``.left ``=` `self``.right ``=` `None`   `# Function to print the flattened` `# binary Tree` `def` `print_(parent):`   `    ``curr ``=` `parent` `    ``while` `(curr !``=` `None``):` `        ``print``( curr.data ,end ``=` `" "``)` `        ``curr ``=` `curr.right`   `prev ``=` `None`   `# Function to perform post-order traversal` `# recursively` `def` `postorder( curr ):` `    `  `    ``global` `prev` `    `  `    ``# Base case` `    ``if` `(curr ``=``=` `None``):` `        ``return` `    ``postorder(curr.left)` `    ``postorder(curr.right)` `    ``prev.left ``=` `None` `    ``prev.right ``=` `curr` `    ``prev ``=` `curr`   `# Function to flatten the given binary tree` `# using post order traversal` `def` `flatten(parent):`   `    ``global` `prev` `    `  `    ``# Dummy node` `    ``dummy ``=` `node(``-``1``)`   `    ``# Pointer to previous element` `    ``prev ``=` `dummy`   `    ``# Calling post-order traversal` `    ``postorder(parent)`   `    ``prev.left ``=` `None` `    ``prev.right ``=` `None` `    ``ret ``=` `dummy.right`   `    ``return` `ret`   `# Driver code` `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``)`   `print_(flatten(root))`     `# This code is contributed by Arnab Kundu`

## C#

 `// C# implementation of the 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``;` `    ``}` `};` `static` `node prev;`   `// Function to print the flattened` `// binary Tree` `static` `void` `print(node parent)` `{` `    ``node curr = parent;` `    ``while` `(curr != ``null``)` `    ``{` `        ``Console.Write(curr.data + ``" "``);` `        ``curr = curr.right;` `    ``}` `}`   `// Function to perform post-order traversal` `// recursively` `static` `void` `postorder(node curr)` `{` `    ``// Base case` `    ``if` `(curr == ``null``)` `        ``return``;` `    ``postorder(curr.left);` `    ``postorder(curr.right);` `    ``prev.left = ``null``;` `    ``prev.right = curr;` `    ``prev = curr;` `}`   `// Function to flatten the given binary tree` `// using post order traversal` `static` `node flatten(node parent)` `{` `    ``// Dummy node` `    ``node dummy = ``new` `node(-1);`   `    ``// Pointer to previous element` `    ``prev = dummy;`   `    ``// Calling post-order traversal` `    ``postorder(parent);`   `    ``prev.left = ``null``;` `    ``prev.right = ``null``;` `    ``node ret = dummy.right;`   `    ``// Delete dummy node` `    ``dummy = ``null``;` `    ``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);`   `    ``print(flatten(root));` `}` `}`   `// This code is contributed by Princi Singh`

## Javascript

 ``

Output:

`2 4 3 6 8 7 5`

Time complexity: O(N)
Auxiliary Space: O(N).   since N extra space has been taken.

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