Convert a given Binary Tree to Doubly Linked List | Set 2

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 same as Inorder of the given Binary Tree. The first node of Inorder traversal (left most node in BT) must be head node of the DLL.

TreeToList

A solution to this problem is discussed in this post.
In this post, another simple and efficient solution is discussed. The solution discussed here has two simple steps.

1) Fix Left Pointers: In this step, we change left pointers to point to previous nodes in DLL. The idea is simple, we do inorder traversal of tree. In inorder traversal, we keep track of previous visited node and change left pointer to the previous node. See fixPrevPtr() in below implementation.

2) Fix Right Pointers: The above is intuitive and simple. How to change right pointers to point to next node in DLL? The idea is to use left pointers fixed in step 1. We start from the rightmost node in Binary Tree (BT). The rightmost node is the last node in DLL. Since left pointers are changed to point to previous node in DLL, we can linearly traverse the complete DLL using these pointers. The traversal would be from last to first node. While traversing the DLL, we keep track of the previously visited node and change the right pointer to the previous node. See fixNextPtr() in below implementation.

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// A simple inorder traversal based 
// program to convert a Binary Tree to DLL 
#include <bits/stdc++.h>
using namespace std;
  
// A tree node 
class node 
    public:
    int data; 
    node *left, *right; 
}; 
  
// A utility function to create
// a new tree node 
node *newNode(int data) 
    node *Node = new node();
    Node->data = data; 
    Node->left = Node->right = NULL; 
    return(Node); 
  
// Standard Inorder traversal of tree 
void inorder(node *root) 
    if (root != NULL) 
    
        inorder(root->left); 
        cout << "\t" << root->data; 
        inorder(root->right); 
    
  
// Changes left pointers to work as 
// previous pointers in converted DLL 
// The function simply does inorder 
// traversal of Binary Tree and updates 
// left pointer using previously visited node 
void fixPrevPtr(node *root) 
    static node *pre = NULL; 
  
    if (root != NULL) 
    
        fixPrevPtr(root->left); 
        root->left = pre; 
        pre = root; 
        fixPrevPtr(root->right); 
    
  
// Changes right pointers to work 
// as next pointers in converted DLL 
node *fixNextPtr(node *root) 
    node *prev = NULL; 
  
    // Find the right most node 
    // in BT or last node in DLL 
    while (root && root->right != NULL) 
        root = root->right; 
  
    // Start from the rightmost node, 
    // traverse back using left pointers. 
    // While traversing, change right pointer of nodes. 
    while (root && root->left != NULL) 
    
        prev = root; 
        root = root->left; 
        root->right = prev; 
    
  
    // The leftmost node is head 
    // of linked list, return it 
    return (root); 
  
// The main function that converts 
// BST to DLL and returns head of DLL 
node *BTToDLL(node *root) 
    // Set the previous pointer 
    fixPrevPtr(root); 
  
    // Set the next pointer and return head of DLL 
    return fixNextPtr(root); 
  
// Traverses the DLL from left tor right 
void printList(node *root) 
    while (root != NULL) 
    
        cout<<"\t"<<root->data; 
        root = root->right; 
    
  
// Driver code 
int main(void
    // 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); 
  
    cout<<"\n\t\tInorder Tree Traversal\n\n"
    inorder(root); 
  
    node *head = BTToDLL(root); 
  
    cout << "\n\n\t\tDLL Traversal\n\n"
    printList(head); 
    return 0; 
}
  
// This code is contributed by rathbhupendra

chevron_right


C

filter_none

edit
close

play_arrow

link
brightness_4
code

// A simple inorder traversal based program to convert a Binary Tree to DLL
#include<stdio.h>
#include<stdlib.h>
  
// A tree node
struct node
{
    int data;
    struct node *left, *right;
};
  
// A utility function to create a new tree node
struct node *newNode(int data)
{
    struct node *node = (struct node *)malloc(sizeof(struct node));
    node->data = data;
    node->left = node->right = NULL;
    return(node);
}
  
// Standard Inorder traversal of tree
void inorder(struct node *root)
{
    if (root != NULL)
    {
        inorder(root->left);
        printf("\t%d",root->data);
        inorder(root->right);
    }
}
  
// Changes left pointers to work as previous pointers in converted DLL
// The function simply does inorder traversal of Binary Tree and updates
// left pointer using previously visited node
void fixPrevPtr(struct node *root)
{
    static struct node *pre = NULL;
  
    if (root != NULL)
    {
        fixPrevPtr(root->left);
        root->left = pre;
        pre = root;
        fixPrevPtr(root->right);
    }
}
  
// Changes right pointers to work as next pointers in converted DLL
struct node *fixNextPtr(struct node *root)
{
    struct node *prev = NULL;
  
    // Find the right most node in BT or last node in DLL
    while (root && root->right != NULL)
        root = root->right;
  
    // Start from the rightmost node, traverse back using left pointers.
    // While traversing, change right pointer of nodes.
    while (root && root->left != NULL)
    {
        prev = root;
        root = root->left;
        root->right = prev;
    }
  
    // The leftmost node is head of linked list, return it
    return (root);
}
  
// The main function that converts BST to DLL and returns head of DLL
struct node *BTToDLL(struct node *root)
{
    // Set the previous pointer
    fixPrevPtr(root);
  
    // Set the next pointer and return head of DLL
    return fixNextPtr(root);
}
  
// Traverses the DLL from left tor right
void printList(struct node *root)
{
    while (root != NULL)
    {
        printf("\t%d", root->data);
        root = root->right;
    }
}
  
// Driver program to test above functions
int main(void)
{
    // Let us create the tree shown in 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);
  
    printf("\n\t\tInorder Tree Traversal\n\n");
    inorder(root);
  
    struct node *head = BTToDLL(root);
  
    printf("\n\n\t\tDLL Traversal\n\n");
    printList(head);
    return 0;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java program to convert BTT to DLL using
// simple inorder traversal
  
public class BinaryTreeToDLL 
{
    static class node 
    {
        int data;
        node left, right;
  
        public node(int data) 
        {
            this.data = data;
        }
    }
  
    static node prev;
  
    // Changes left pointers to work as previous 
    // pointers in converted DLL The function 
    // simply does inorder traversal of Binary 
    // Tree and updates left pointer using 
    // previously visited node
    static void fixPrevptr(node root) 
    {
        if (root == null)
            return;
  
        fixPrevptr(root.left);
        root.left = prev;
        prev = root;
        fixPrevptr(root.right);
  
    }
  
    // Changes right pointers to work 
    // as next pointers in converted DLL
    static node fixNextptr(node root) 
    {        
        // Find the right most node in 
        // BT or last node in DLL
        while (root.right != null)
            root = root.right;
  
        // Start from the rightmost node, traverse 
        // back using left pointers. While traversing, 
        // change right pointer of nodes
        while (root != null && root.left != null
        {
            node left = root.left;
            left.right = root;
            root = root.left;
        }
  
        // The leftmost node is head of linked list, return it
        return root;
    }
  
    static node BTTtoDLL(node root) 
    {
        prev = null;
  
        // Set the previous pointer
        fixPrevptr(root);
  
        // Set the next pointer and return head of DLL
        return fixNextptr(root);
    }
  
    // Traverses the DLL from left tor right
    static void printlist(node root) 
    {
        while (root != null
        {
            System.out.print(root.data + " ");
            root = root.right;
        }
    }
  
    // Standard Inorder traversal of tree
    static void inorder(node root) 
    {
        if (root == null)
            return;
        inorder(root.left);
        System.out.print(root.data + " ");
        inorder(root.right);
    }
  
    public static void main(String[] args) 
    {
        // Let us create the tree shown in above diagram
        node 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);
  
        System.out.println("Inorder Tree Traversal");
        inorder(root);
  
        node head = BTTtoDLL(root);
  
        System.out.println("\nDLL Traversal");
        printlist(head);
    }
}
  
// This code is contributed by Rishabh Mahrsee

chevron_right


Python

filter_none

edit
close

play_arrow

link
brightness_4
code

# A simple inorder traversal based program to convert a 
# Binary Tree to DLL
  
# A Binary Tree node
class Node:
      
    # Constructor to create a new tree node
    def __init__(self, data):
        self.data = data 
        self.left = None
        self.right = None
  
# Standard Inorder traversal of tree
def inorder(root):
      
    if root is not None:
        inorder(root.left)
        print "\t%d" %(root.data),
        inorder(root.right)
  
# Changes left pointers to work as previous pointers
# in converted DLL
# The function simply does inorder traversal of 
# Binary Tree and updates
# left pointer using previously visited node
def fixPrevPtr(root):
    if root is not None:
        fixPrevPtr(root.left)
        root.left = fixPrevPtr.pre
        fixPrevPtr.pre = root 
        fixPrevPtr(root.right)
  
# Changes right pointers to work as nexr pointers in
# converted DLL 
def fixNextPtr(root):
  
    prev = None
    # Find the right most node in BT or last node in DLL
    while(root and root.right != None):
        root = root.right 
  
    # Start from the rightmost node, traverse back using
    # left pointers
    # While traversing, change right pointer of nodes 
    while(root and root.left != None):
        prev = root 
        root = root.left 
        root.right = prev
  
    # The leftmost node is head of linked list, return it
    return root 
  
# The main function that converts BST to DLL and returns
# head of DLL
def BTToDLL(root):
      
    # Set the previous pointer 
    fixPrevPtr(root)
  
    # Set the next pointer and return head of DLL
    return fixNextPtr(root)
  
# Traversses the DLL from left to right 
def printList(root):
    while(root != None):
        print "\t%d" %(root.data),
        root = root.right
  
# Driver program to test above function
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)
  
print "\n\t\t Inorder Tree Traversal\n"
inorder(root)
  
# Static variable pre for function fixPrevPtr
fixPrevPtr.pre = None
head = BTToDLL(root)
  
print "\n\n\t\tDLL Traversal\n"
printList(head)
      
# This code is contributed by Nikhil Kumar Singh(nickzuck_007)

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# program to convert BTT to DLL using 
// simple inorder traversal 
using System;
  
class GFG
{
public class node
{
    public int data;
    public node left, right;
  
    public node(int data)
    {
        this.data = data;
    }
}
  
public static node prev;
  
// Changes left pointers to work as previous 
// pointers in converted DLL The function 
// simply does inorder traversal of Binary 
// Tree and updates left pointer using 
// previously visited node 
public static void fixPrevptr(node root)
{
    if (root == null)
    {
        return;
    }
  
    fixPrevptr(root.left);
    root.left = prev;
    prev = root;
    fixPrevptr(root.right);
  
}
  
// Changes right pointers to work 
// as next pointers in converted DLL 
public static node fixNextptr(node root)
{
    // Find the right most node in 
    // BT or last node in DLL 
    while (root.right != null)
    {
        root = root.right;
    }
  
    // Start from the rightmost node, traverse 
    // back using left pointers. While traversing, 
    // change right pointer of nodes 
    while (root != null && root.left != null)
    {
        node left = root.left;
        left.right = root;
        root = root.left;
    }
  
    // The leftmost node is head of 
    // linked list, return it 
    return root;
}
  
public static node BTTtoDLL(node root)
{
    prev = null;
  
    // Set the previous pointer 
    fixPrevptr(root);
  
    // Set the next pointer and 
    // return head of DLL 
    return fixNextptr(root);
}
  
// Traverses the DLL from left tor right 
public static void printlist(node root)
{
    while (root != null)
    {
        Console.Write(root.data + " ");
        root = root.right;
    }
}
  
// Standard Inorder traversal of tree 
public static void inorder(node root)
{
    if (root == null)
    {
        return;
    }
    inorder(root.left);
    Console.Write(root.data + " ");
    inorder(root.right);
}
  
public static void Main()
{
    // Let us create the tree 
    // shown in above diagram 
    node 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);
  
    Console.WriteLine("Inorder Tree Traversal");
    inorder(root);
  
    node head = BTTtoDLL(root);
  
    Console.WriteLine("\nDLL Traversal");
    printlist(head);
}
}
  
// This code is contributed by Shrikant13

chevron_right



Output:

                Inorder Tree Traversal

        25      12      30      10      36      15

                DLL Traversal

        25      12      30      10      36      15

Time Complexity: O(n) where n is the number of nodes in given Binary Tree. The solution simply does two traversals of all Binary Tree nodes.

This article is contributed by Bala. Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above



My Personal Notes arrow_drop_up

Improved By : shrikanth13, rathbhupendra