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.
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.
-
If the left subtree exists, process the left subtree
- Recursively convert the left subtree to DLL.
- Then find the inorder predecessor of the root in the left subtree (the inorder predecessor is the rightmost node in the left subtree).
- Make the inorder predecessor as the previous root and the root as the next in order predecessor.
-
If the right subtree exists, process the right subtree (Below 3 steps are similar to the left subtree).
- Recursively convert the right subtree to DLL.
- Then find the inorder successor of the root in the right subtree (in order the successor is the leftmost node in the right subtree).
- Make the inorder successor as the next root and the root as the previous inorder successor.
- 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.
// A C++ program for in-place // conversion of Binary Tree to DLL #include <bits/stdc++.h> 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 predecessor 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 |
#include <stdio.h> // Definition of a binary tree node struct node {
int data;
struct node* left;
struct node* right;
}; // Utility function to convert a binary tree to a doubly // linked list struct node* bintree2listUtil( struct node* root)
{ // Base case: If the tree is empty, return NULL
if (root == NULL)
return root;
// Convert the left subtree and link to the root
if (root->left != NULL) {
// Convert the left subtree
struct 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 the root as the next of the predecessor
left->right = root;
// Make the predecessor as the previous of the root
root->left = left;
}
// Convert the right subtree and link to the root
if (root->right != NULL) {
// Convert the right subtree
struct 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 the root as the previous of the successor
right->left = root;
// Make the successor as the next of the root
root->right = right;
}
return root;
} // Main function that first calls bintree2listUtil() and // then follows step 3 of the algorithm struct node* bintree2list( struct node* root)
{ // Base case: If the tree is empty, return NULL
if (root == NULL)
return root;
// Convert to doubly linked list using
// bintree2listUtil()
root = bintree2listUtil(root);
// bintree2listUtil() returns the root node of the
// converted doubly linked list We need a pointer to the
// leftmost node which is the head of the constructed
// doubly linked list Move to the leftmost node
while (root->left != NULL)
root = root->left;
return (root);
} // Helper function to allocate a new node with the given // data and NULL left and right pointers struct node* newNode( int data)
{ struct node* new_node
= ( struct node*) malloc ( sizeof ( struct 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( struct node* node)
{ while (node != NULL) {
printf ( "%d " , node->data);
node = node->right;
}
} // Driver program to test the above functions int main()
{ // Let us create the tree shown in the above diagram
struct 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 the binary tree to a doubly linked list
struct node* head = bintree2list(root);
// Print the converted doubly linked list
printList(head);
return 0;
} |
// 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 predecessor 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 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 |
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 predecessor 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 |
<script> // javascript program to convert binary tree to double linked list
/* A binary tree node has data, and left and right pointers */
class Node {
constructor(val) {
this .data = val;
this .left = null ;
this .right = null ;
}
}
var root;
/*
* This is the core function to convert Tree to list. This function follows
* steps 1 and 2 of the above algorithm
*/
function bintree2listUtil(node) {
// Base case
if (node == null )
return node;
// Convert the left subtree and link to root
if (node.left != null ) {
// Convert the left subtree
var 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 predecessor as previous of root
node.left = left;
}
// Convert the right subtree and link to root
if (node.right != null ) {
// Convert the right subtree
var 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
function bintree2list(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 */
function printList(node) {
while (node != null ) {
document.write(node.data + " " );
node = node.right;
}
}
/* Driver program to test above functions */
// Let us create the tree shown in above diagram
root = new Node(10);
root.left = new Node(12);
root.right = new Node(15);
root.left.left = new Node(25);
root.left.right = new Node(30);
root.right.left = new Node(36);
// Convert to DLL
var head = bintree2list(root);
// Print the converted list
printList(head);
// This code contributed by umadevi9616 </script> |
25 12 30 10 36 15
Time Complexity: O(n).
Auxiliary Space: O(1).
Another Approach:
Algorithm:
- Traverse the tree in inorder fashion.
- 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.
- Return head of the list.
Below is the implementation of the above approach:
// A C++ program for in-place // conversion of Binary Tree to DLL #include <bits/stdc++.h> 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 ;
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 |
// A Java program for in-place // conversion of Binary Tree to DLL import java.util.*;
public class GFG {
/* A binary tree node has data,
and left and right pointers */
static class node {
int data;
node left;
node right;
};
/*
* This is the core function to convert Tree to list.
*/
static node head, tail;
static void bintree2listUtil(node root)
{
if (root == null )
return ;
node left = root.left;
node right = root.right;
bintree2listUtil(root.left);
if (head == null ) {
head = root;
}
root.left = tail;
if (tail != null ) {
(tail).right = root;
}
tail = root;
bintree2listUtil(root.right);
}
// The main function that first calls
// bintree2listUtil()
static void bintree2list(node root)
{
// Base case
if (root == null )
head = root;
bintree2listUtil(root);
}
/* Helper function that allocates a new node with the
given data and null left and right pointers. */
static 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
*/
static void printList()
{
while (head != null ) {
System.out.print(head.data + " " );
head = head.right;
}
}
/* Driver code */
public static void main(String[] args)
{
// 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 );
head = null ;
tail = null ;
// Convert to DLL
bintree2list(root);
// Print the converted list
printList();
}
} // This code is contributed by umadevi9616 |
# A Python3 program for in-place # conversion of Binary Tree to DLL # A binary tree node has data, # and left and right pointers class newNode( object ):
def __init__( self ,data):
self .data = data
self .left = None
self .right = None
head = None
tail = None
# This is the core function to convert Tree to list. def bintree2listUtil(root):
if (root = = None ):
return
left = root.left
right = root.right
global head
global tail
bintree2listUtil(root.left)
if (head = = None ):
head = root
root.left = tail
if (tail ! = None ):
tail.right = root
tail = root
bintree2listUtil(root.right)
# The main function that first calls # bintree2listUtil() def bintree2list(root):
# Base case
global head
if (root = = None ):
head = root
bintree2listUtil(root)
# Function to print nodes in a given doubly linked list def printList():
global head
while head:
print (head.data, end = " " )
head = head.right
# Driver Code if __name__ = = '__main__' :
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 )
bintree2list(root)
printList()
# This code is contributed by Abhijeet Kumar(abhijeet19403) |
// A C# program for in-place // conversion of Binary Tree to DLL using System;
public class GFG {
/*
* A binary tree node has data, and left and right pointers
*/
public class node {
public int data;
public node left;
public node right;
};
/*
* This is the core function to convert Tree to list.
*/
static node head, tail;
static void bintree2listUtil(node root) {
if (root == null )
return ;
node left = root.left;
node right = root.right;
bintree2listUtil(root.left);
if (head == null ) {
head = root;
}
root.left = tail;
if (tail != null ) {
(tail).right = root;
}
tail = root;
bintree2listUtil(root.right);
}
// The main function that first calls
// bintree2listUtil()
static void bintree2list(node root) {
// Base case
if (root == null )
head = root;
bintree2listUtil(root);
}
/*
* Helper function that allocates a new node with the given data and null left
* and right pointers.
*/
static 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 */
static void printList() {
while (head != null ) {
Console.Write(head.data + " " );
head = head.right;
}
}
/* Driver code */
public static void Main(String[] args) {
// 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);
head = null ;
tail = null ;
// Convert to DLL
bintree2list(root);
// Print the converted list
printList();
}
} // This code is contributed by gauravrajput1 |
<script> // A javascript program for in-place // conversion of Binary Tree to DLL /*
* A binary tree node has data, and left and right pointers
*/
class Node {
constructor() {
this .data = 0;
this .left = null ;
this .right = null ;
}
}
/*
* This is the core function to convert Tree to list.
*/
var head, tail;
function bintree2listUtil(root) {
if (root == null )
return ;
var left = root.left;
var right = root.right;
bintree2listUtil(root.left);
if (head == null ) {
head = root;
}
root.left = tail;
if (tail != null ) {
(tail).right = root;
}
tail = root;
bintree2listUtil(root.right);
}
// The main function that first calls
// bintree2listUtil()
function bintree2list( root) {
// Base case
if (root == null )
head = root;
bintree2listUtil(root);
}
/*
* Helper function that allocates a new node with the given data and null left
* and right pointers.
*/
function newNode(data) {
var 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 */
function printList() {
while (head != null ) {
document.write(head.data + " " );
head = head.right;
}
}
/* Driver code */
// Let us create the tree shown in above diagram
var 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);
head = null ;
tail = null ;
// Convert to DLL
bintree2list(root);
// Print the converted list
printList();
// This code is contributed by gauravrajput1 </script> |
25 12 30 10 36 15
Time Complexity: O(n) where n is the number of nodes in given Binary Tree.
Auxiliary Space: O(h) where h is the height of given Binary Tree due to Recursion
This article is compiled by Ashish Mangla and reviewed by GeeksforGeeks team.
You may also like to see Convert a given Binary Tree to Doubly Linked List | Set 2 for another simple and efficient solution.