Flatten Binary Tree in order of Level Order Traversal - GeeksforGeeks

17 Dec, 2021
Given a Binary Tree, the task is to flatten it in order of Level order traversal of the tree. In the flattened binary tree, the left node of all the nodes must be NULL.Examples:  
Input: 
          1 
        /   \ 
       5     2 
      / \   / \ 
     6   4 9   3 
Output: 1 5 2 6 4 9 3

Input:
      1
       \
        2
         \
          3
           \
            4
             \
              5
Output: 1 2 3 4 5
 
Approach: We will solve this problem by simulating the Level order traversal of Binary Tree as follows:  
Create a queue to store the nodes of Binary tree.Create a variable “prev” and initialise it by parent node.Push left and right children of parent in the queue.Apply level order traversal. Lets say “curr” is front most element in queue. Then, If ‘curr’ is NULL, continue.Else push curr->left and curr->right in the queueSet prev = curr
Create a queue to store the nodes of Binary tree.
Create a variable “prev” and initialise it by parent node.
Push left and right children of parent in the queue.
Apply level order traversal. Lets say “curr” is front most element in queue. Then, If ‘curr’ is NULL, continue.Else push curr->left and curr->right in the queueSet prev = curr
If ‘curr’ is NULL, continue.
Else push curr->left and curr->right in the queue
Set prev = curr
Below is the implementation of the above approach:  
C++
Java
Python3
C#
Javascript
// 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 flatten Binary tree using// level order traversalvoid flatten(node* parent){    // Queue to store nodes    // for BFS    queue<node*> q;    q.push(parent->left);    q.push(parent->right);    node* prev = parent;     // Code for BFS    while (q.size()) {                 // Size of queue        int s = q.size();        while (s--) {                         // Front most node in            // the queue            node* curr = q.front();            q.pop();             // Base case            if (curr == NULL)                continue;            prev->right = curr;            prev->left = NULL;            prev = curr;             // Pushing new elements            // in queue            q.push(curr->left);            q.push(curr->right);        }    }     prev->left = NULL;    prev->right = NULL;} // Function to print flattened// Binary Treevoid print(node* parent){    node* curr = parent;    while (curr != NULL)        cout << curr->data << " ", curr = curr->right;} // Driver codeint main(){    node* root = new node(1);    root->left = new node(5);    root->right = new node(2);    root->left->left = new node(6);    root->left->right = new node(4);    root->right->left = new node(9);    root->right->right = new node(3);     // Calling required functions    flatten(root);    print(root);         return 0;}
// Java implementation of the approachimport java.util.*; class GFG{     // Node of the Binary treestatic class node{    int data;    node left;    node right;    node(int data)    {        this.data = data;        left = null;        right = null;    }}; // Function to flatten Binary tree using// level order traversalstatic void flatten(node parent){    // Queue to store nodes    // for BFS    Queue<node> q = new LinkedList<>();    q.add(parent.left);    q.add(parent.right);    node prev = parent;     // Code for BFS    while (q.size() > 0)    {                 // Size of queue        int s = q.size();        while (s-- > 0)        {                         // Front most node in            // the queue            node curr = q.peek();            q.remove();             // Base case            if (curr == null)                continue;            prev.right = curr;            prev.left = null;            prev = curr;             // Pushing new elements            // in queue            q.add(curr.left);            q.add(curr.right);        }    }    prev.left = null;    prev.right = null;} // Function to print flattened// Binary Treestatic void print(node parent){    node curr = parent;    while (curr != null)    {        System.out.print(curr.data + " ");        curr = curr.right;    }} // Driver codepublic static void main(String[] args){    node root = new node(1);    root.left = new node(5);    root.right = new node(2);    root.left.left = new node(6);    root.left.right = new node(4);    root.right.left = new node(9);    root.right.right = new node(3);     // Calling required functions    flatten(root);    print(root);}} // This code is contributed by Rajput-Ji
# Python implementation of above algorithm # Utility class to create a nodeclass node:    def __init__(self, key):        self.data = key        self.left = self.right = None # Function to flatten Binary tree using# level order traversaldef flatten( parent):     # Queue to store nodes    # for BFS    q = []    q.append(parent.left)    q.append(parent.right)    prev = parent     # Code for BFS    while (len(q) > 0) :                 # Size of queue        s = len(q)        while (s > 0) :            s = s - 1                         # Front most node in            # the queue            curr = q[0]            q.pop(0)             # Base case            if (curr == None):                continue            prev.right = curr            prev.left = None            prev = curr             # appending elements            # in queue            q.append(curr.left)            q.append(curr.right)             prev.left = None    prev.right = None # Function to print flattened# Binary Treedef print_(parent):     curr = parent    while (curr != None):        print( curr.data , end=" ")        curr = curr.right # Driver coderoot = node(1)root.left = node(5)root.right = node(2)root.left.left = node(6)root.left.right = node(4)root.right.left = node(9)root.right.right = node(3) # Calling required functionsflatten(root)print_(root)     # This code is contributed by Arnab Kundu
// C# implementation of the approachusing System;using System.Collections.Generic; 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;    }}; // Function to flatten Binary tree using// level order traversalstatic void flatten(node parent){    // Queue to store nodes    // for BFS    Queue<node> q = new Queue<node>();    q.Enqueue(parent.left);    q.Enqueue(parent.right);    node prev = parent;     // Code for BFS    while (q.Count > 0)    {                 // Size of queue        int s = q.Count;        while (s-- > 0)        {                         // Front most node in            // the queue            node curr = q.Peek();            q.Dequeue();             // Base case            if (curr == null)                continue;            prev.right = curr;            prev.left = null;            prev = curr;             // Pushing new elements            // in queue            q.Enqueue(curr.left);            q.Enqueue(curr.right);        }    }    prev.left = null;    prev.right = null;} // Function to print flattened// Binary Treestatic void print(node parent){    node curr = parent;    while (curr != null)    {        Console.Write(curr.data + " ");        curr = curr.right;    }} // Driver codepublic static void Main(String[] args){    node root = new node(1);    root.left = new node(5);    root.right = new node(2);    root.left.left = new node(6);    root.left.right = new node(4);    root.right.left = new node(9);    root.right.right = new node(3);     // Calling required functions    flatten(root);    print(root);}} // This code is contributed by Rajput-Ji
<script>// Javascript implementation of the approach // Node of the Binary treeclass node{    constructor(data)    {        this.data = data;        this.left = null;        this.right = null;    }} // Function to flatten Binary tree using// level order traversalfunction flatten(parent){    // Queue to store nodes    // for BFS    let q = [];    q.push(parent.left);    q.push(parent.right);    let prev = parent;       // Code for BFS    while (q.length > 0)    {                   // Size of queue        let s = q.length;        while (s-- > 0)        {                           // Front most node in            // the queue            let curr = q.shift();                            // Base case            if (curr == null)                continue;            prev.right = curr;            prev.left = null;            prev = curr;               // Pushing new elements            // in queue            q.push(curr.left);            q.push(curr.right);        }    }    prev.left = null;    prev.right = null;} // Function to print flattened// Binary Treefunction print(parent){    let curr = parent;    while (curr != null)    {        document.write(curr.data + " ");        curr = curr.right;    }} // Driver codelet root = new node(1);root.left = new node(5);root.right = new node(2);root.left.left = new node(6);root.left.right = new node(4);root.right.left = new node(9);root.right.right = new node(3); // Calling required functionsflatten(root);print(root); // This code is contributed by avanitrachhadiya2155</script>
Output :  
1 5 2 6 4 9 3 
Time Complexity: O(N) Space Complexity: O(N) where N is the size of Binary Tree. 
Rajput-Ji
andrew1234
avanitrachhadiya2155
amartyaghoshgfg
Binary Tree
tree-level-order
Algorithms
Algorithms
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
SDE SHEET - A Complete Guide for SDE Preparation
DSA Sheet by Love Babbar
How to Start Learning DSA?
Introduction to Algorithms
Difference between NP hard and NP complete problem
Converting Roman Numerals to Decimal lying between 1 to 3999
Quick Sort vs Merge Sort
Generate all permutation of a set in Python
Difference Between Symmetric and Asymmetric Key Encryption
Difference between Algorithm, Pseudocode and Program