Related Articles

# Convert a given Binary Tree to Doubly Linked List | Set 1

• Difficulty Level : Hard
• Last Updated : 20 Aug, 2021
`Given a Binary Tree (Bt), convert it to a Doubly Linked List(DLL). The left and right pointers in nodes are to be used as previous and next pointers respectively in converted DLL. The order of nodes in DLL must be the same as in Inorder for the given Binary Tree. The first node of Inorder traversal (leftmost node in BT) must be the head node of the DLL. ` I came across this question during one of my interviews. A similar problem has been discussed in this post

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

The problem here is simpler as we don’t need to create a circular DLL, but a simple DLL. The idea behind its solution is quite simple and straight.

1. If the left subtree exists, process the left subtree
1. Recursively convert the left subtree to DLL.
2. Then find the inorder predecessor of the root in the left subtree (the inorder predecessor is the rightmost node in the left subtree).
3. Make the inorder predecessor as the previous root and the root as the next in order predecessor.
2.  If the right subtree exists, process the right subtree (Below 3 steps are similar to the left subtree).
1. Recursively convert the right subtree to DLL.
2. Then find the inorder successor of the root in the right subtree (in order the successor is the leftmost node in the right subtree).
3. Make the inorder successor as the next root and the root as the previous inorder successor.
3. Find the leftmost node and return it (the leftmost node is always the head of a converted DLL).

Below is the source code for the above algorithm.

## C++

 `// A C++ program for in-place``// conversion of Binary Tree to DLL``#include ``using` `namespace` `std;` `/* A binary tree node has data,``and left and right pointers */``class` `node {``public``:``    ``int` `data;``    ``node* left;``    ``node* right;``};` `/* This is the core function to convert``Tree to list. This function follows``steps 1 and 2 of the above algorithm */``node* bintree2listUtil(node* root)``{``    ``// Base case``    ``if` `(root == NULL)``        ``return` `root;` `    ``// Convert the left subtree and link to root``    ``if` `(root->left != NULL) {``        ``// Convert the left subtree``        ``node* left = bintree2listUtil(root->left);` `        ``// Find inorder predecessor. After this loop, left``        ``// will point to the inorder predecessor``        ``for` `(; left->right != NULL; left = left->right)``            ``;` `        ``// Make root as next of the predecessor``        ``left->right = root;` `        ``// Make predecssor as previous of root``        ``root->left = left;``    ``}` `    ``// Convert the right subtree and link to root``    ``if` `(root->right != NULL) {``        ``// Convert the right subtree``        ``node* right = bintree2listUtil(root->right);` `        ``// Find inorder successor. After this loop, right``        ``// will point to the inorder successor``        ``for` `(; right->left != NULL; right = right->left)``            ``;` `        ``// Make root as previous of successor``        ``right->left = root;` `        ``// Make successor as next of root``        ``root->right = right;``    ``}` `    ``return` `root;``}` `// The main function that first calls``// bintree2listUtil(), then follows step 3``// of the above algorithm``node* bintree2list(node* root)``{``    ``// Base case``    ``if` `(root == NULL)``        ``return` `root;` `    ``// Convert to DLL using bintree2listUtil()``    ``root = bintree2listUtil(root);` `    ``// bintree2listUtil() returns root node of the converted``    ``// DLL. We need pointer to the leftmost node which is``    ``// head of the constructed DLL, so move to the leftmost``    ``// node``    ``while` `(root->left != NULL)``        ``root = root->left;` `    ``return` `(root);``}` `/* Helper function that allocates a new node with the``given data and NULL left and right pointers. */``node* newNode(``int` `data)``{``    ``node* new_node = ``new` `node();``    ``new_node->data = data;``    ``new_node->left = new_node->right = NULL;``    ``return` `(new_node);``}` `/* Function to print nodes in a given doubly linked list */``void` `printList(node* node)``{``    ``while` `(node != NULL) {``        ``cout << node->data << ``" "``;``        ``node = node->right;``    ``}``}` `/* Driver code*/``int` `main()``{``    ``// Let us create the tree shown in above diagram``    ``node* root = newNode(10);``    ``root->left = newNode(12);``    ``root->right = newNode(15);``    ``root->left->left = newNode(25);``    ``root->left->right = newNode(30);``    ``root->right->left = newNode(36);` `    ``// Convert to DLL``    ``node* head = bintree2list(root);` `    ``// Print the converted list``    ``printList(head);` `    ``return` `0;``}` `// This code is contributed by rathbhupendra`

## C

 `// A C program for in-place conversion of Binary Tree to DLL``#include ` `/* A binary tree node has data, and left and right pointers */``struct` `node``{``    ``int` `data;``    ``node* left;``    ``node* right;``};` `/* This is the core function to convert Tree to list. This function follows``  ``steps 1 and 2 of the above algorithm */``node* bintree2listUtil(node* root)``{``    ``// Base case``    ``if` `(root == NULL)``        ``return` `root;` `    ``// Convert the left subtree and link to root``    ``if` `(root->left != NULL)``    ``{``        ``// Convert the left subtree``        ``node* left = bintree2listUtil(root->left);` `        ``// Find inorder predecessor. After this loop, left``        ``// will point to the inorder predecessor``        ``for` `(; left->right!=NULL; left=left->right);` `        ``// Make root as next of the predecessor``        ``left->right = root;` `        ``// Make predecssor as previous of root``        ``root->left = left;``    ``}` `    ``// Convert the right subtree and link to root``    ``if` `(root->right!=NULL)``    ``{``        ``// Convert the right subtree``        ``node* right = bintree2listUtil(root->right);` `        ``// Find inorder successor. After this loop, right``        ``// will point to the inorder successor``        ``for` `(; right->left!=NULL; right = right->left);` `        ``// Make root as previous of successor``        ``right->left = root;` `        ``// Make successor as next of root``        ``root->right = right;``    ``}` `    ``return` `root;``}` `// The main function that first calls bintree2listUtil(), then follows step 3``//  of the above algorithm``node* bintree2list(node *root)``{``    ``// Base case``    ``if` `(root == NULL)``        ``return` `root;` `    ``// Convert to DLL using bintree2listUtil()``    ``root = bintree2listUtil(root);` `    ``// bintree2listUtil() returns root node of the converted``    ``// DLL.  We need pointer to the leftmost node which is``    ``// head of the constructed DLL, so move to the leftmost node``    ``while` `(root->left != NULL)``        ``root = root->left;` `    ``return` `(root);``}` `/* Helper function that allocates a new node with the``   ``given data and NULL left and right pointers. */``node* newNode(``int` `data)``{``    ``node* new_node = ``new` `node;``    ``new_node->data = data;``    ``new_node->left = new_node->right = NULL;``    ``return` `(new_node);``}` `/* Function to print nodes in a given doubly linked list */``void` `printList(node *node)``{``    ``while` `(node!=NULL)``    ``{``        ``printf``(``"%d "``, node->data);``        ``node = node->right;``    ``}``}` `/* Driver program to test above functions*/``int` `main()``{``    ``// Let us create the tree shown in above diagram``    ``node *root        = newNode(10);``    ``root->left        = newNode(12);``    ``root->right       = newNode(15);``    ``root->left->left  = newNode(25);``    ``root->left->right = newNode(30);``    ``root->right->left = newNode(36);` `    ``// Convert to DLL``    ``node *head = bintree2list(root);` `    ``// Print the converted list``    ``printList(head);` `    ``return` `0;``}`

## Java

 `// Java program to convert binary tree to double linked list`` ` `/* A binary tree node has data, and left and right pointers */``class` `Node``{``    ``int` `data;``    ``Node left, right;`` ` `    ``Node(``int` `item)``    ``{``        ``data = item;``        ``left = right = ``null``;``    ``}``}`` ` `class` `BinaryTree``{``    ``Node root;``    ``/* This is the core function to convert Tree to list. This function``       ``follows steps 1 and 2 of the above algorithm */`` ` `    ``Node bintree2listUtil(Node node)``    ``{``        ``// Base case``        ``if` `(node == ``null``)``            ``return` `node;`` ` `        ``// Convert the left subtree and link to root``        ``if` `(node.left != ``null``)``        ``{``            ``// Convert the left subtree``            ``Node left = bintree2listUtil(node.left);`` ` `            ``// Find inorder predecessor. After this loop, left``            ``// will point to the inorder predecessor``            ``for` `(; left.right != ``null``; left = left.right);`` ` `            ``// Make root as next of the predecessor``            ``left.right = node;`` ` `            ``// Make predecssor as previous of root``            ``node.left = left;``        ``}`` ` `        ``// Convert the right subtree and link to root``        ``if` `(node.right != ``null``)``        ``{``            ``// Convert the right subtree``            ``Node right = bintree2listUtil(node.right);`` ` `            ``// Find inorder successor. After this loop, right``            ``// will point to the inorder successor``            ``for` `(; right.left != ``null``; right = right.left);`` ` `            ``// Make root as previous of successor``            ``right.left = node;`` ` `            ``// Make successor as next of root``            ``node.right = right;``        ``}`` ` `        ``return` `node;``    ``}`` ` `    ``// The main function that first calls bintree2listUtil(), then follows``    ``// step 3 of the above algorithm``     ` `    ``Node bintree2list(Node node)``    ``{``        ``// Base case``        ``if` `(node == ``null``)``            ``return` `node;`` ` `        ``// Convert to DLL using bintree2listUtil()``        ``node = bintree2listUtil(node);`` ` `        ``// bintree2listUtil() returns root node of the converted``        ``// DLL.  We need pointer to the leftmost node which is``        ``// head of the constructed DLL, so move to the leftmost node``        ``while` `(node.left != ``null``)``            ``node = node.left;`` ` `        ``return` `node;``    ``}`` ` `    ``/* Function to print nodes in a given doubly linked list */``    ``void` `printList(Node node)``    ``{``        ``while` `(node != ``null``)``        ``{``            ``System.out.print(node.data + ``" "``);``            ``node = node.right;``        ``}``    ``}`` ` `    ``/* Driver program to test above functions*/``    ``public` `static` `void` `main(String[] args)``    ``{``        ``BinaryTree tree = ``new` `BinaryTree();`` ` `        ``// Let us create the tree shown in above diagram``        ``tree.root = ``new` `Node(``10``);``        ``tree.root.left = ``new` `Node(``12``);``        ``tree.root.right = ``new` `Node(``15``);``        ``tree.root.left.left = ``new` `Node(``25``);``        ``tree.root.left.right = ``new` `Node(``30``);``        ``tree.root.right.left = ``new` `Node(``36``);`` ` `        ``// Convert to DLL``        ``Node head = tree.bintree2list(tree.root);`` ` `        ``// Print the converted list``        ``tree.printList(head);``    ``}``}`

## Python

 `# Python program to convert``# binary tree to doubly linked list` `class` `Node(``object``):``    ` `    ``"""Binary tree Node class has``    ``data, left and right child"""``    ``def` `__init__(``self``, item):``        ``self``.data ``=` `item``        ``self``.left ``=` `None``        ``self``.right ``=` `None` `def` `BTToDLLUtil(root):``    ` `    ``"""This is a utility function to``    ``convert the binary tree to doubly``    ``linked list. Most of the core task``    ``is done by this function."""``    ``if` `root ``is` `None``:``        ``return` `root` `    ``# Convert left subtree``    ``# and link to root``    ``if` `root.left:``        ` `        ``# Convert the left subtree``        ``left ``=` `BTToDLLUtil(root.left)` `        ``# Find inorder predecessor, After``        ``# this loop, left will point to the``        ``# inorder predecessor of root``        ``while` `left.right:``            ``left ``=` `left.right` `        ``# Make root as next of predecessor``        ``left.right ``=` `root``        ` `        ``# Make predecessor as``        ``# previous of root``        ``root.left ``=` `left` `    ``# Convert the right subtree``    ``# and link to root``    ``if` `root.right:``        ` `        ``# Convert the right subtree``        ``right ``=` `BTToDLLUtil(root.right)` `        ``# Find inorder successor, After``        ``# this loop, right will point to``        ``# the inorder successor of root``        ``while` `right.left:``            ``right ``=` `right.left` `        ``# Make root as previous``        ``# of successor``        ``right.left ``=` `root``        ` `        ``# Make successor as``        ``# next of root``        ``root.right ``=` `right` `    ``return` `root` `def` `BTToDLL(root):``    ``if` `root ``is` `None``:``        ``return` `root` `    ``# Convert to doubly linked``    ``# list using BLLToDLLUtil``    ``root ``=` `BTToDLLUtil(root)``    ` `    ``# We need pointer to left most``    ``# node which is head of the``    ``# constructed Doubly Linked list``    ``while` `root.left:``        ``root ``=` `root.left` `    ``return` `root` `def` `print_list(head):``    ` `    ``"""Function to print the given``       ``doubly linked list"""``    ``if` `head ``is` `None``:``        ``return``    ``while` `head:``        ``print``(head.data, end ``=` `" "``)``        ``head ``=` `head.right` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``    ``root ``=` `Node(``10``)``    ``root.left ``=` `Node(``12``)``    ``root.right ``=` `Node(``15``)``    ``root.left.left ``=` `Node(``25``)``    ``root.left.right ``=` `Node(``30``)``    ``root.right.left ``=` `Node(``36``)` `    ``head ``=` `BTToDLL(root)``    ``print_list(head)` `# This code is contributed``# by viveksyngh`

## C#

 `using` `System;` `// C# program to convert binary tree to double linked list` `/* A binary tree node has data, and left and right pointers */``public` `class` `Node``{``    ``public` `int` `data;``    ``public` `Node left, right;` `    ``public` `Node(``int` `item)``    ``{``        ``data = item;``        ``left = right = ``null``;``    ``}``}` `public` `class` `BinaryTree``{``    ``public` `Node root;``    ``/* This is the core function to convert Tree to list. This function``       ``follows steps 1 and 2 of the above algorithm */` `    ``public` `virtual` `Node bintree2listUtil(Node node)``    ``{``        ``// Base case``        ``if` `(node == ``null``)``        ``{``            ``return` `node;``        ``}` `        ``// Convert the left subtree and link to root``        ``if` `(node.left != ``null``)``        ``{``            ``// Convert the left subtree``            ``Node left = bintree2listUtil(node.left);` `            ``// Find inorder predecessor. After this loop, left``            ``// will point to the inorder predecessor``            ``for` `(; left.right != ``null``; left = left.right)``            ``{``                ``;``            ``}` `            ``// Make root as next of the predecessor``            ``left.right = node;` `            ``// Make predecssor as previous of root``            ``node.left = left;``        ``}` `        ``// Convert the right subtree and link to root``        ``if` `(node.right != ``null``)``        ``{``            ``// Convert the right subtree``            ``Node right = bintree2listUtil(node.right);` `            ``// Find inorder successor. After this loop, right``            ``// will point to the inorder successor``            ``for` `(; right.left != ``null``; right = right.left)``            ``{``                ``;``            ``}` `            ``// Make root as previous of successor``            ``right.left = node;` `            ``// Make successor as next of root``            ``node.right = right;``        ``}` `        ``return` `node;``    ``}` `    ``// The main function that first calls bintree2listUtil(), then follows``    ``// step 3 of the above algorithm` `    ``public` `virtual` `Node bintree2list(Node node)``    ``{``        ``// Base case``        ``if` `(node == ``null``)``        ``{``            ``return` `node;``        ``}` `        ``// Convert to DLL using bintree2listUtil()``        ``node = bintree2listUtil(node);` `        ``// bintree2listUtil() returns root node of the converted``        ``// DLL.  We need pointer to the leftmost node which is``        ``// head of the constructed DLL, so move to the leftmost node``        ``while` `(node.left != ``null``)``        ``{``            ``node = node.left;``        ``}` `        ``return` `node;``    ``}` `    ``/* Function to print nodes in a given doubly linked list */``    ``public` `virtual` `void` `printList(Node node)``    ``{``        ``while` `(node != ``null``)``        ``{``            ``Console.Write(node.data + ``" "``);``            ``node = node.right;``        ``}``    ``}` `    ``/* Driver program to test above functions*/``    ``public` `static` `void` `Main(``string``[] args)``    ``{``        ``BinaryTree tree = ``new` `BinaryTree();` `        ``// Let us create the tree shown in above diagram``        ``tree.root = ``new` `Node(10);``        ``tree.root.left = ``new` `Node(12);``        ``tree.root.right = ``new` `Node(15);``        ``tree.root.left.left = ``new` `Node(25);``        ``tree.root.left.right = ``new` `Node(30);``        ``tree.root.right.left = ``new` `Node(36);` `        ``// Convert to DLL``        ``Node head = tree.bintree2list(tree.root);` `        ``// Print the converted list``        ``tree.printList(head);``    ``}``}` `// This code is contributed by Shrikant13`

## Javascript

 ``
Output
`25 12 30 10 36 15 `

Another Approach:
Algorithm:

1. Traverse the tree in inorder fashion.
2. While visiting each node, keep track of DLL’s head and tail pointers, insert each visited node to the end of DLL using tail pointer.
3. Return head of the list.

Below is the implementation of the above approach:

## C++

 `// A C++ program for in-place``// conversion of Binary Tree to DLL``#include ``using` `namespace` `std;` `/* A binary tree node has data,``and left and right pointers */``class` `node {``public``:``    ``int` `data;``    ``node* left;``    ``node* right;``};` `/* This is the core function to convert``Tree to list.*/``void` `bintree2listUtil(node* root, node** head, node** tail)``{``    ``if` `(root == NULL)``        ``return` `NULL;` `    ``node* left = root->left;``    ``node* right = root->right;` `    ``bintree2listUtil(root->left, head, tail);` `    ``if` `(*head == NULL) {``        ``*head = root;``    ``}` `    ``root->left = *tail;` `    ``if` `(*tail != NULL) {``        ``(*tail)->right = root;``    ``}` `    ``*tail = root;` `    ``bintree2listUtil(root->right, head, tail);``}` `// The main function that first calls``// bintree2listUtil()``node* bintree2list(node* root)``{``    ``// Base case``    ``if` `(root == NULL)``        ``return` `root;` `    ``node* head = NULL;``    ``node* tail = NULL;` `    ``bintree2listUtil(root, &head, &tail);` `    ``return` `head;``}` `/* Helper function that allocates a new node with the``given data and NULL left and right pointers. */``node* newNode(``int` `data)``{``    ``node* new_node = ``new` `node();``    ``new_node->data = data;``    ``new_node->left = new_node->right = NULL;``    ``return` `(new_node);``}` `/* Function to print nodes in a given doubly linked list */``void` `printList(node* node)``{``    ``while` `(node != NULL) {``        ``cout << node->data << ``" "``;``        ``node = node->right;``    ``}``}` `/* Driver code*/``int` `main()``{``    ``// Let us create the tree shown in above diagram``    ``node* root = newNode(10);``    ``root->left = newNode(12);``    ``root->right = newNode(15);``    ``root->left->left = newNode(25);``    ``root->left->right = newNode(30);``    ``root->right->left = newNode(36);` `    ``// Convert to DLL``    ``node* head = bintree2list(root);` `    ``// Print the converted list``    ``printList(head);` `    ``return` `0;``}` `// This code is contributed by rathbhupendra`
Output
`25 12 30 10 36 15 `