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.
- Create a dummy node.
- Create variable called ‘prev’ and make it point to the dummy node.
- 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 <bits/stdc++.h>using namespace std;// Node of the binary treestruct node { int data; node* left; node* right; node(int data) { this->data = data; left = NULL; right = NULL; }};// Function to print the flattened// binary Treevoid print(node* parent){ node* curr = parent; while (curr != NULL) cout << curr->data << " ", curr = curr->right;}// Function to perform post-order traversal// recursivelyvoid 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 traversalnode* 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 codeint 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 approachclass GFG{// Node of the binary treestatic 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 Treestatic void print(node parent){ node curr = parent; while (curr != null) { System.out.print(curr.data + " "); curr = curr.right; }}// Function to perform post-order traversal// recursivelystatic 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 traversalstatic 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 codepublic 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 Treedef print_(parent): curr = parent while (curr != None): print( curr.data ,end = " ") curr = curr.rightprev = None# Function to perform post-order traversal# recursivelydef 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 traversaldef 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 coderoot = 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 approachusing System;class GFG{// Node of the binary treepublic 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 Treestatic void print(node parent){ node curr = parent; while (curr != null) { Console.Write(curr.data + " "); curr = curr.right; }}// Function to perform post-order traversal// recursivelystatic 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 traversalstatic 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 codepublic 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
<script>// Javascript implementation of the approach// Node of the binary treeclass node { constructor(data) { this.data = data; this.left = null; this.right = null; }};var prev = null;// Function to print the flattened// binary Treefunction print(parent){ var curr = parent; while (curr != null) { document.write(curr.data + " "); curr = curr.right; }}// Function to perform post-order traversal// recursivelyfunction postorder(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 traversalfunction flatten(parent){ // Dummy node var dummy = new node(-1); // Pointer to previous element prev = dummy; // Calling post-order traversal postorder(parent); prev.left = null; prev.right = null; var ret = dummy.right; // Delete dummy node dummy = null; return ret;}// Driver codevar 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 noob2000</script> |
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 neveropen!
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 neveropen!
