# Flatten a binary tree into linked list

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     6Output :    1     \      2       \        3         \          4           \            5             \              6Input :        1       / \      3   4         /        2         \          5Output :     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,

Implementation:

## C++

 `// C++ Program to flatten a given Binary Tree into linked` `// list by using Morris Traversal concept` `#include ` `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 ` `#include `   `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);` `}`   `/* 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);`   `    ``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 ` `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);` `}`   `/* 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 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 ` `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` `        ``stackst;` `        ``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;` `}`

## 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 stack = ``new` `Stack();` `        ``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);` `    ``}` `}`

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.