Flatten a binary tree into linked list (original) (raw)

Last Updated : 11 Jul, 2025

Given a binary tree, flatten it into linked list in-place. Usage of auxiliary data structure is not allowed. After flattening, left of each node should point to NULL and right should contain next node in preorder.

**Examples:

**Input :
1
/ \
2 5
/ \ \
3 4 6
**Output :
1
\
2
\
3
\
4
\
5
\
6
**Input :
1
/ \
3 4
/
2
\
5
**Output :
1
\
3
\
4
\
2
\
5

**Simple Approach: A simple solution is to use Level Order Traversal using Queue. In level order traversal, keep track of previous node. Make current node as right child of previous and left of previous node as NULL. This solution requires queue, but question asks to solve without additional data structure.

**Efficient Without Additional Data Structure Recursively look for the node with no grandchildren and both left and right child in the left sub-tree. Then store node->right in temp and make node->right=node->left. Insert temp in first node NULL on right of node by node=node->right. Repeat until it is converted to linked list. Even though this approach does not require additional data structure , but still it takes space for Recursion stack.

For Example,

Flatten Binary Tree Example

**Implementation:

Try It Yourself

C++ `

// C++ Program to flatten a given Binary Tree into linked // list by using Morris Traversal concept #include <bits/stdc++.h> using namespace std;

struct Node { int key; Node *left, *right; };

// utility that allocates a new Node with the given key Node* newNode(int key) { Node* node = new Node; node->key = key; node->left = node->right = NULL; return (node); }

// Function to convert binary tree into linked list by // altering the right node and making left node point to // NULL void flatten(struct Node* root) { // base condition- return if root is NULL or if it is a // leaf node if (root == NULL || root->left == NULL && root->right == NULL) return; // if root->left exists then we have to make it // root->right if (root->left != NULL) { // move left recursively flatten(root->left); // store the node root->right struct Node* tmpRight = root->right; root->right = root->left; root->left = NULL; // find the position to insert the stored value struct Node* t = root->right; while (t->right != NULL) t = t->right; // insert the stored value t->right = tmpRight; } // now call the same function for root->right flatten(root->right); }

// To find the inorder traversal void inorder(struct Node* root) { // base condition if (root == NULL) return; inorder(root->left); cout << root->key << " "; inorder(root->right); }

/* Driver program to test above functions*/ int main() { /* 1 /
2 5 / \
3 4 6 / Node root = newNode(1); root->left = newNode(2); root->right = newNode(5); root->left->left = newNode(3); root->left->right = newNode(4); root->right->right = newNode(6); flatten(root); cout << "The Inorder traversal after flattening binary tree "; inorder(root); return 0; }

// This code is contributed by Aditya Kumar (adityakumar129)

C

// C Program to flatten a given Binary Tree into linked // list #include <stdio.h> #include <stdlib.h>

typedef struct Node { int key; struct Node *left, *right; }Node;

// utility that allocates a new Node with the given key Node* newNode(int key) { Node* node = (Node*)malloc(sizeof(Node)); node->key = key; node->left = node->right = NULL; return (node); }

// Function to convert binary tree into linked list by // altering the right node and making left node point to // NULL void flatten(Node* root) { // base condition- return if root is NULL or if it is a // leaf node if (root == NULL || root->left == NULL && root->right == NULL) return;

// if root->left exists then we have to make it
// root->right
if (root->left != NULL) {
    // move left recursively
    flatten(root->left);
    // store the node root->right
    struct Node* tmpRight = root->right;
    root->right = root->left;
    root->left = NULL;
    // find the position to insert the stored value
    struct Node* t = root->right;
    while (t->right != NULL)
        t = t->right;
    // insert the stored value
    t->right = tmpRight;
}

// now call the same function for root->right
flatten(root->right);

}

// To find the inorder traversal void inorder(struct Node* root) { // base condition if (root == NULL) return; inorder(root->left); printf("%d ", root->key); inorder(root->right); }

flatten(root);

printf("The Inorder traversal after flattening binary tree ");
inorder(root);
return 0;

}

// This code is contributed by aditykumar129.

Java

// Java program to flatten a given Binary Tree into linked // list

// A binary tree node class Node { int data; Node left, right; Node(int key) { data = key; left = right = null; } }

class BinaryTree {

Node root;

// Function to convert binary tree into linked list by
// altering the right node and making left node NULL
public void flatten(Node node)
{
    // Base case - return if root is NULL
    if (node == null)
        return;
    // Or if it is a leaf node
    if (node.left == null && node.right == null)
        return;
    // If root.left children exists then we have to make
    // it node.right (where node is root)
    if (node.left != null) {
        // Move left recursively
        flatten(node.left);
        // Store the node.right in Node named tempNode
        Node tempNode = node.right;
        node.right = node.left;
        node.left = null;
        // Find the position to insert the stored value
        Node curr = node.right;
        while (curr.right != null)
            curr = curr.right;
        // Insert the stored value
        curr.right = tempNode;
    }
    // Now call the same function for node.right
    flatten(node.right);
}
// Function for Inorder traversal
public void inOrder(Node node)
{
    // Base Condition
    if (node == null)
        return;
    inOrder(node.left);
    System.out.print(node.data + " ");
    inOrder(node.right);
}

// Driver code
public static void main(String[] args)
{
    BinaryTree tree = new BinaryTree();

    /*    1
        /   \
       2     5
      / \     \
     3   4     6 */

    tree.root = new Node(1);
    tree.root.left = new Node(2);
    tree.root.right = new Node(5);
    tree.root.left.left = new Node(3);
    tree.root.left.right = new Node(4);
    tree.root.right.right = new Node(6);

    System.out.println(
        "The Inorder traversal after flattening binary tree ");
    tree.flatten(tree.root);
    tree.inOrder(tree.root);
}

}

// This code is contributed by Aditya Kumar (adityakumar129)

Python3

Python3 program to flatten a given Binary

Tree into linked list

class Node:

def __init__(self):
    
    self.key = 0
    self.left = None
    self.right = None

Utility that allocates a new Node

with the given key

def newNode(key):

node = Node()
node.key = key
node.left = node.right = None
return (node)

Function to convert binary tree into

linked list by altering the right node

and making left node point to None

def flatten(root):

# Base condition- return if root is None
# or if it is a leaf node
if (root == None or root.left == None and
                    root.right == None):
    return

# If root.left exists then we have 
# to make it root.right
if (root.left != None):

    # Move left recursively
    flatten(root.left)

    # Store the node root.right
    tmpRight = root.right
    root.right = root.left
    root.left = None

    # Find the position to insert
    # the stored value   
    t = root.right
    while (t.right != None):
        t = t.right

    # Insert the stored value
    t.right = tmpRight

# Now call the same function
# for root.right
flatten(root.right)

To find the inorder traversal

def inorder(root):

# Base condition
if (root == None):
    return

inorder(root.left)
print(root.key, end = ' ')
inorder(root.right)

Driver Code

if name=='main':

'''   1
    /   \
   2     5
  / \     \
 3   4     6 '''
root = newNode(1)
root.left = newNode(2)
root.right = newNode(5)
root.left.left = newNode(3)
root.left.right = newNode(4)
root.right.right = newNode(6)

flatten(root)

print("The Inorder traversal after "
      "flattening binary tree ",
      end = '')
inorder(root)

This code is contributed by pratham76

C#

// C# program to flatten a given // Binary Tree into linked list using System;

// A binary tree node class Node { public int data; public Node left, right;

public Node(int key) { data = key; left = right = null; } }

class BinaryTree {
Node root;

// Function to convert binary tree into // linked list by altering the right node // and making left node NULL public void flatten(Node node) {

// Base case - return if root is NULL
if (node == null)
  return;

// Or if it is a leaf node
if (node.left == null &&
    node.right == null)
  return;

// If root.left children exists then we have
// to make it node.right (where node is root)
if (node.left != null)
{

  // Move left recursively
  flatten(node.left);

  // Store the node.right in 
  // Node named tempNode
  Node tempNode = node.right;
  node.right = node.left;
  node.left = null;

  // Find the position to insert
  // the stored value
  Node curr = node.right;
  while (curr.right != null) 
  {
    curr = curr.right;
  }

  // Insert the stored value
  curr.right = tempNode;
}

// Now call the same function
// for node.right
flatten(node.right);

}

// Function for Inorder traversal public void inOrder(Node node) {

// Base Condition
if (node == null)
  return;
inOrder(node.left);
Console.Write(node.data + " ");
inOrder(node.right);

}

// Driver code public static void Main(string[] args) { BinaryTree tree = new BinaryTree();

/* 1
    / \
2     5
/ \     \
3 4     6 */

tree.root = new Node(1);
tree.root.left = new Node(2);
tree.root.right = new Node(5);
tree.root.left.left = new Node(3);
tree.root.left.right = new Node(4);
tree.root.right.right = new Node(6);
Console.Write("The Inorder traversal after " +
              "flattening binary tree ");                        
tree.flatten(tree.root);
tree.inOrder(tree.root);

} }

// This code is contributed by rutvik_56

JavaScript

Output

The Inorder traversal after flattening binary tree 1 2 3 4 5 6

**Complexity Analysis:

**Time Complexity: **O(n), traverse the whole tree
**Space Complexity: **O(n), Extra space used for recursion call.

**Another Approach:
We will use the intuition behind Morris’s traversal. In Morris Traversal we use the concept of a threaded binary tree.

At a node(say cur) if there exists a left child, we will find the rightmost node in the left subtree(say prev).
We will set prev’s right child to cur’s right child,
We will then set cur’s right child to it’s left child.
We will then move cur to the next node by assigning cur it to its right child
We will stop the execution when cur points to NULL.

**Implementation:

C++ `

// C++ Program to flatten a given Binary Tree into linked // list #include <bits/stdc++.h> using namespace std;

struct Node { int key; Node *left, *right; };

// utility that allocates a new Node with the given key Node* newNode(int key) { Node* node = new Node; node->key = key; node->left = node->right = NULL; return (node); }

// Function to convert binary tree into linked list by // altering the right node and making left node point to // NULL void flatten(Node* root) { // traverse till root is not NULL while (root) { // if root->left is not NULL if (root->left != NULL) { // set curr node as root->left; Node* curr = root->left; // traverse to the extreme right of curr while (curr->right) { curr = curr->right; } // join curr->right to root->right curr->right = root->right; // put root->left to root->right root->right = root->left; // make root->left as NULL root->left = NULL; } // now go to the right of the root root = root->right; } }

// To find the inorder traversal void inorder(struct Node* root) { // base condition if (root == NULL) return; inorder(root->left); cout << root->key << " "; inorder(root->right); }

// This code is contributed by Harsh Raghav

Java

// Java Program to flatten a given Binary Tree into linked // list import java.io.*;

class Node { int key; Node left, right; }

class GFG {

// utility that allocates a new Node with the given key static Node newNode(int key) { Node node = new Node(); node.key = key; node.left = node.right = null; return node; }

// Function to convert binary tree into linked list by // altering the right node and making left node point to // NULL static void flatten(Node root) { // traverse till root is not NULL while (root != null) { // if root->left is not NULL if (root.left != null) { // set curr node as root->left; Node curr = root.left; // traverse to the extreme right of curr while (curr.right != null) { curr = curr.right; } // join curr->right to root->right curr.right = root.right; // put root->left to root->right root.right = root.left; // make root->left as NULL root.left = null; } // now go to the right of the root root = root.right; } }

// To find the inorder traversal static void inorder(Node root) { // base condition if (root == null) { return; } inorder(root.left); System.out.print(root.key + " "); inorder(root.right); }

public static void main(String[] args) {

/*    1
        /   \
          2     5
        / \     \
      3   4     6  */

Node root = newNode(1);
root.left = newNode(2);
root.right = newNode(5);
root.left.left = newNode(3);
root.left.right = newNode(4);
root.right.right = newNode(6);
flatten(root);

System.out.print(
  "The Inorder traversal after flattening binary tree ");
inorder(root);

} }

// This code is contributed by lokesh.

Python3

Python3 program to flatten a given Binary

Tree into linked list

class Node:

def __init__(self):
    
    self.key = 0
    self.left = None
    self.right = None

def newNode(key): node = Node() node.key = key node.left = node.right = None return (node)

Function to convert binary tree into

linked list by altering the right node

and making left node point to None

def flatten(root):

# traverse till root is not None
while(root != None):
    # if root.left is not None
    if(root.left != None):
        # set curr node as root.left
        curr = root.left
        # traverse to the extreme right of curr
        while(curr.right != None):
            curr = curr.right
        # join curr.right to root.right
        curr.right = root.right
        # put root.left to root.right
        root.right = root.left
        # make root.left as None
        root.left = None
    # now go to the right of the root
    root = root.right

To find the inorder traversal

def inorder(root):

# Base condition
if (root == None):
    return

inorder(root.left)
print(root.key, end = ' ')
inorder(root.right)

Driver Code

if name=='main':

'''   1
    /   \
   2     5
  / \     \
 3   4     6 '''
root = newNode(1)
root.left = newNode(2)
root.right = newNode(5)
root.left.left = newNode(3)
root.left.right = newNode(4)
root.right.right = newNode(6)

flatten(root)

print("The Inorder traversal after "
      "flattening binary tree ",
      end = '')
inorder(root)

This code is contributed by Yash Agarwal(yashagarwal2852002)

C#

// C# program to flatten a given Binary Tree into linked list using System;

class Node { public int data; public Node left, right;

public Node(int key) { data = key; left = right = null; } }

class BinaryTree {
Node root;

// Function to convert binary tree into // linked list by altering the right node // and making left node NULL public void flatten(Node node) { // traverse till node is not NULL while(node != null){ // if node->left is not NULL if(node.left != null){ // set curr node as node->left; Node curr = node.left; // traverse to the extreme right of curr while(curr.right != null){ curr = curr.right; } // join curr->right to node->right curr.right = node.right; // put node->left to node->right node.right = node.left; // make node->left as NULL node.left = null; } // now go to the right of the node node = node.right; } }

// Function for Inorder traversal public void inorder(Node node) { // Base Condition if (node == null) return; inorder(node.left); Console.Write(node.data + " "); inorder(node.right); }

// Driver program to test above functions public static void Main(string[] args) { BinaryTree tree = new BinaryTree();

/*   1
    / \
   2   5
  / \   \
  3 4    6 */

tree.root = new Node(1);
tree.root.left = new Node(2);
tree.root.right = new Node(5);
tree.root.left.left = new Node(3);
tree.root.left.right = new Node(4);
tree.root.right.right = new Node(6);
Console.Write("The Inorder traversal after " +
              "flattening binary tree ");                        
tree.flatten(tree.root);
tree.inorder(tree.root);

} }

// This code is contributed by Yash Agarwal(yashagarwal2852002)

JavaScript

Output

The Inorder traversal after flattening binary tree 1 2 3 4 5 6

**Time Complexity: O(N) Time complexity will be the same as that of a Morris's traversal
**Auxiliary Space: O(1)

**Another Approach Using Stack:

In this solution, we start by initializing a prev variable to None. This variable will keep track of the previously flattened node as we recursively flatten the binary tree.

We then define a recursive function flatten that takes in the root node of the binary tree. This function does not return anything, but instead modifies the tree in-place.
The first thing we do in the flatten function is to check if the root node is None. If it is, we simply return.
Next, we recursively flatten the right subtree of the root node by calling self.flatten(root.right). This will flatten the right subtree and set self.prev to the rightmost node in the right subtree.
We then recursively flatten the left subtree of the root node by calling self.flatten(root.left). This will flatten the left subtree and update self.prev to the rightmost node in the flattened left subtree.
Once we have flattened both the left and right subtrees, we update the root.right pointer to be the previously flattened node (self.prev). We also set the root.left pointer to None to remove the left child.
Finally, we update self.prev to be the current node (root). This is important because it allows us to keep track of the previously flattened node as we continue to recursively flatten the tree.

This algorithm flattens the binary tree in pre-order traversal, so the resulting "linked list" will be in the same order as a pre-order traversal of the tree.

**Implementation:

C++ `

// C++ Program to flatten a given Binary Tree into linked // list #include <bits/stdc++.h> using namespace std;

struct Node { int key; Node *left, *right; };

// utility that allocates a new Node with the given key Node* newNode(int key) { Node* node = new Node; node->key = key; node->left = node->right = NULL; return (node); }

// Function to convert binary tree into linked list by // altering the right node and making left node point to // NULL

void flatten(Node* root) { // Base case: if the current node is null, return null stack<Node *>st; st.push(root); // If the left subtree was flattened, merge it with the current node // If the right subtree was flattened, return its tail node // If neither subtree was flattened, return the current node as the tail node while(st.empty()!=true) { Node *curr = st.top(); st.pop(); if(curr==NULL) return; if(curr->right!=NULL) st.push(curr->right);// Connect the right subtree of the left tail to the right subtree of the current node if(curr->left!=NULL) st.push(curr->left);// Make the left subtree the new right subtree of the current node if(st.empty()!=true)// Set the left child of the current node to null { curr->right = st.top(); } curr->left = NULL; } return; }

void inorder(struct Node* root) { // base condition if (root == NULL) return; inorder(root->left); cout << root->key << " "; inorder(root->right); }

int main() { /* 1 /
2 5 / \
3 4 6 / Node root = newNode(1); root->left = newNode(2); root->right = newNode(5); root->left->left = newNode(3); root->left->right = newNode(4); root->right->right = newNode(6); // Call the recursive helper function flatten(root); cout << "The Inorder traversal after flattening binary " "tree "; inorder(root); return 0; }

Java

import java.io.*; import java.util.Stack;

class Node { int key; Node left, right;

Node(int item) {
    key = item;
    left = right = null;
}

} public class GFG { // Function to flatten binary tree into // linked list public static void flatten(Node root) { if (root == null) { return; } Stack stack = new Stack<>(); stack.push(root); while (!stack.isEmpty()) { Node current = stack.pop();

        if (current.right != null) {
            stack.push(current.right);
        }

        if (current.left != null) {
            stack.push(current.left);
        }

        if (!stack.isEmpty()) {
            current.right = stack.peek();
        }

        current.left = null;
    }
}
// Function to perform an inorder traversal and

// print the elements public static void inorder(Node root) { if (root == null) { return; } inorder(root.left); System.out.print(root.key + " "); inorder(root.right); } public static void main(String[] args) { /* Construct the binary tree: 1 /
2 5 / \
3 4 6 */ Node root = new Node(1); root.left = new Node(2); root.right = new Node(5); root.left.left = new Node(3); root.left.right = new Node(4); root.right.right = new Node(6); // Flatten the binary tree into a linked list flatten(root); System.out.print("Inorder traversal after flattening binary tree "); inorder(root); } }

Python3

class TreeNode: def init(self, key): self.key = key self.left = None self.right = None

def flatten(root): if not root: return

stack = [root]

while stack:
    curr = stack.pop()
    if not curr:
        continue

    if curr.right:
        stack.append(curr.right)  # Connect the right subtree of the left tail to the right subtree of the current node
    if curr.left:
        stack.append(curr.left)  # Make the left subtree the new right subtree of the current node

    if stack:
        curr.right = stack[-1]
    curr.left = None

def inorder(root): if not root: return inorder(root.left) print(root.key, end=' ') inorder(root.right)

Main function

if name == "main": # Construct the binary tree # 1 # /
# 2 5 # / \
# 3 4 6 root = TreeNode(1) root.left = TreeNode(2) root.right = TreeNode(5) root.left.left = TreeNode(3) root.left.right = TreeNode(4) root.right.right = TreeNode(6)

# Call the flatten function
flatten(root)

print("The Inorder traversal after flattening binary tree:")
inorder(root)

This code is contributed by shivamgupta0987654321

C#

using System; using System.Collections.Generic;

public class Node { public int key; public Node left, right; }

public class FlattenBinaryTreeToLinkedList {

// Utility function to create a new Node with the given key
static Node NewNode(int key) {
    Node node = new Node();
    node.key = key;
    node.left = node.right = null;
    return node;
}

// Function to flatten a binary tree into a linked list
static void Flatten(Node root) {
    if (root == null) return;

    // Create a stack to perform a preorder traversal of the binary tree
    Stack<Node> stack = new Stack<Node>();
    stack.Push(root);

    while (stack.Count != 0) {
        Node curr = stack.Pop();
        if (curr == null) continue;

        // Push the right and left children onto the stack (preorder)
        if (curr.right != null) stack.Push(curr.right);
        if (curr.left != null) stack.Push(curr.left);

        if (stack.Count != 0) {
            // Set the current node's right pointer to the next node in the stack
            curr.right = stack.Peek();
        }
        // Clear the left pointer as we are converting the tree to a linked list
        curr.left = null;
    }
}

// Function to perform an inorder traversal of the binary tree
static void Inorder(Node root) {
    if (root == null) return;
    Inorder(root.left);
    Console.Write(root.key + " "); // Print the current node's key
    Inorder(root.right);
}

public static void Main(string[] args) {
    // Create a sample binary tree
    Node root = NewNode(1);
    root.left = NewNode(2);
    root.right = NewNode(5);
    root.left.left = NewNode(3);
    root.left.right = NewNode(4);
    root.right.right = NewNode(6);

    // Call the Flatten function to convert the tree to a linked list
    Flatten(root);

    // Print the inorder traversal of the flattened binary tree (linked list)
    Console.Write("The Inorder traversal after flattening binary tree ");
    Inorder(root);
}

}

JavaScript

class TreeNode { constructor(key) { this.key = key; this.left = null; this.right = null; } }

// Function to convert a binary tree into a linked list by altering the right node and making the left node point to null function flatten(root) { // Base case: if the current node is null, return null const stack = [root];

// If the left subtree was flattened, merge it with the current node
// If the right subtree was flattened, return its tail node
// If neither subtree was flattened, return the current node as the tail node
while (stack.length > 0) {
    const curr = stack.pop();
    if (curr === null) {
        return;
    }
    if (curr.right !== null) {
        stack.push(curr.right); // Connect the right subtree of the left tail to the right subtree of the current node
    }
    if (curr.left !== null) {
        stack.push(curr.left); // Make the left subtree the new right subtree of the current node
    }
    if (stack.length > 0) {
        curr.right = stack[stack.length - 1];
    }
    curr.left = null;
}

}

// Function to perform an inorder traversal of the tree function inorder(root) { // Base condition if (root === null) { return; } inorder(root.left); console.log(root.key + " "); inorder(root.right); }

// Main function function main() { /* 1 /
2 5 / \
3 4 6 */ const root = new TreeNode(1); root.left = new TreeNode(2); root.right = new TreeNode(5); root.left.left = new TreeNode(3); root.left.right = new TreeNode(4); root.right.right = new TreeNode(6);

// Call the flatten function
flatten(root);
console.log("The Inorder traversal after flattening binary tree:");
inorder(root);

}

// Run the main function main();

Output

The Inorder traversal after flattening binary tree 1 2 3 4 5 6

**Time Complexity: O(N), The loop will execute for every node once.
**Space Complexity: O(N), Auxiliary Stack Space is needed.