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

23 Feb, 2022
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.  
A solution to this problem has been 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 in order traversal of the tree. In order to traversal, we keep track of the previously visited node and change the left pointer to the previous node. See fixPrevPtr() implementation below. 2) Fix Right Pointers: The above is intuitive and simple. How to change the right pointers to point to the 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 the previous node in DLL, we can linearly traverse the complete DLL using these pointers. The traversal would be from last to the 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() implementation below.  
C++
C
Java
Python3
C#
Javascript
// A simple inorder traversal based// program to convert a Binary Tree to DLL#include <bits/stdc++.h>using namespace std; // A tree nodeclass node{    public:    int data;    node *left, *right;}; // A utility function to create// a new tree nodenode *newNode(int data){    node *Node = new node();    Node->data = data;    Node->left = Node->right = NULL;    return(Node);} // Standard Inorder traversal of treevoid 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 nodevoid 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 DLLnode *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 DLLnode *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 to rightvoid printList(node *root){    while (root != NULL)    {        cout<<"\t"<<root->data;        root = root->right;    }} // Driver codeint 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
// A simple inorder traversal based program to convert a Binary Tree to DLL#include<stdio.h>#include<stdlib.h> // A tree nodestruct node{    int data;    struct node *left, *right;}; // A utility function to create a new tree nodestruct 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 treevoid 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 nodevoid 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 DLLstruct 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 DLLstruct 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 to rightvoid printList(struct node *root){    while (root != NULL)    {        printf("\t%d", root->data);        root = root->right;    }} // Driver program to test above functionsint 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;}
// 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 to 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
# A simple inorder traversal based program to convert a# Binary Tree to DLL # A Binary Tree nodeclass 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 treedef inorder(root):         if root is not None:        inorder(root.left)        print ("\t%d" %(root.data),end=" ")        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 nodedef 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 next pointers in# converted DLLdef 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 DLLdef 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 rightdef printList(root):    while(root != None):        print ("\t%d" %(root.data),end=" ")        root = root.right # Driver program to test above functionroot = 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 ("Inorder Tree Traversal")inorder(root) # Static variable pre for function fixPrevPtrfixPrevPtr.pre = Nonehead = BTToDLL(root) print ("\nDLL Traversal")printList(head)     # This code is contributed by Nikhil Kumar Singh(nickzuck_007)
// C# program to convert BTT to DLL using// simple inorder traversalusing 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 nodepublic 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 DLLpublic 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 to rightpublic static void printlist(node root){    while (root != null)    {        Console.Write(root.data + " ");        root = root.right;    }} // Standard Inorder traversal of treepublic 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
<script>    // javascript program to convert BTT to DLL using    // simple inorder traversal     class node {        constructor(val) {            this.data = val;            this.left = null;            this.right = null;        }    }    var 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    function fixPrevptr( 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    function fixNextptr( 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) {            var left = root.left;            left.right = root;            root = root.left;        }         // The leftmost node is head of linked list, return it        return root;    }        function BTTtoDLL( 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 to right    function printlist( root) {        while (root != null) {            document.write(root.data + "   ");            root = root.right;        }    }     // Standard Inorder traversal of tree    function inorder( root) {        if (root == null)            return;        inorder(root.left);        document.write(root.data + "   ");        inorder(root.right);    }          // Let us create the tree shown in above diagram    var 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);     document.write("<br/>Inorder Tree Traversal<br/>");    inorder(root);     var head = BTTtoDLL(root);     document.write("<br/>DLL Traversal<br/>");    printlist(head); // This code contributed by umadevi9616</script>
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 a given Binary Tree. The solution simply does two traversals of all Binary Tree nodes. 
YouTubeGeeksforGeeks507K subscribersConvert a given Binary Tree to Doubly Linked List | Set 2 | GeeksforGeeksWatch laterShareCopy linkInfoShoppingTap to unmuteIf playback doesn't begin shortly, try restarting your device.You're signed outVideos you watch may be added to the TV's watch history and influence TV recommendations. To avoid this, cancel and sign in to YouTube on your computer.CancelConfirmMore videosMore videosSwitch cameraShareInclude playlistAn error occurred while retrieving sharing information. Please try again later.Watch on0:000:000:00 / 7:40•Live•<div class="player-unavailable"><h1 class="message">An error occurred.</h1><div class="submessage"><a href="https://www.youtube.com/watch?v=8kbcUeJDUGA" target="_blank">Try watching this video on www.youtube.com</a>, or enable JavaScript if it is disabled in your browser.</div></div>
This article was contributed by Bala. Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above. 
shrikanth13
rathbhupendra
umadevi9616
amartyaghoshgfg
saurabh1990aror
simmytarika5
Amazon
doubly linked list
Goldman Sachs
Microsoft
Linked List
Tree
Amazon
Microsoft
Goldman Sachs
Linked List
Tree
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Implementing a Linked List in Java using Class
Circular Linked List | Set 1 (Introduction and Applications)
Remove duplicates from a sorted linked list
Function to check if a singly linked list is palindrome
Detect and Remove Loop in a Linked List
Tree Traversals (Inorder, Preorder and Postorder)
AVL Tree | Set 1 (Insertion)
Binary Tree | Set 1 (Introduction)
Level Order Binary Tree Traversal
Binary Tree | Set 3 (Types of Binary Tree)