Extract Leaves of a Binary Tree in a Doubly Linked List - GeeksforGeeks

18 Jan, 2022
Given a Binary Tree, extract all leaves of it in a Doubly Linked List (DLL). Note that the DLL need to be created in-place. Assume that the node structure of DLL and Binary Tree is same, only the meaning of left and right pointers are different. In DLL, left means previous pointer, and right means next pointer.  
Let the following be input binary tree
        1
     /     \
    2       3
   / \       \
  4   5       6
 / \         / \
7   8       9   10


Output:
Doubly Linked List
785910

Modified Tree:
        1
     /     \
    2       3
   /         \
  4           6 
We need to traverse all leaves and connect them by changing their left and right pointers. We also need to remove them from the Binary Tree by changing left or right pointers in parent nodes. There can be many ways to solve this. In the following implementation, we add leaves at the beginning of the current linked list and update the head of the list using the pointer to head pointer. Since we insert at the beginning, we need to process leaves in reverse order. For reverse order, we first traverse the right subtree, then the left subtree. We use return values to update left or right pointers in parent nodes.  
C++
C
Java
Python3
C#
Javascript
// C++ program to extract leaves of// a Binary Tree in a Doubly Linked List#include <bits/stdc++.h>using namespace std; // Structure for tree and linked listclass Node{    public:    int data;    Node *left, *right;}; // Main function which extracts all// leaves from given Binary Tree.// The function returns new root of// Binary Tree (Note that root may change// if Binary Tree has only one node).// The function also sets *head_ref as// head of doubly linked list. left pointer// of tree is used as prev in DLL// and right pointer is used as nextNode* extractLeafList(Node *root, Node **head_ref){// Base casesif (root == NULL) return NULL; if (root->left == NULL && root->right == NULL){    // This node is going to be added    // to doubly linked list of leaves,    // set right pointer of this node    // as previous head of DLL. We    // don't need to set left pointer     // as left is already NULL    root->right = *head_ref;     // Change left pointer of previous head    if (*head_ref != NULL) (*head_ref)->left = root;     // Change head of linked list    *head_ref = root;     return NULL; // Return new root} // Recur for right and left subtreesroot->right = extractLeafList(root->right, head_ref);root->left = extractLeafList(root->left, head_ref); return root;} // Utility function for allocating node for Binary Tree.Node* newNode(int data){    Node* node = new Node();    node->data = data;    node->left = node->right = NULL;    return node;} // Utility function for printing tree in In-Order.void print(Node *root){    if (root != NULL)    {        print(root->left);        cout<<root->data<<" ";        print(root->right);    }} // Utility function for printing double linked list.void printList(Node *head){    while (head)    {        cout<<head->data<<" ";        head = head->right;    }} // Driver codeint main(){    Node *head = NULL;    Node *root = newNode(1);    root->left = newNode(2);    root->right = newNode(3);    root->left->left = newNode(4);    root->left->right = newNode(5);    root->right->right = newNode(6);    root->left->left->left = newNode(7);    root->left->left->right = newNode(8);    root->right->right->left = newNode(9);    root->right->right->right = newNode(10);     cout << "Inorder Traversal of given Tree is:\n";    print(root);     root = extractLeafList(root, &head);     cout << "\nExtracted Double Linked list is:\n";    printList(head);     cout << "\nInorder traversal of modified tree is:\n";    print(root);    return 0;} // This code is contributed by rathbhupendra
// C program to extract leaves of a Binary Tree in a Doubly Linked List#include <stdio.h>#include <stdlib.h> // Structure for tree and linked liststruct Node{    int data;    struct Node *left, *right;}; // Main function which extracts all leaves from given Binary Tree.// The function returns new root of Binary Tree (Note that root may change// if Binary Tree has only one node).  The function also sets *head_ref as// head of doubly linked list.  left pointer of tree is used as prev in DLL// and right pointer is used as nextstruct Node* extractLeafList(struct Node *root, struct Node **head_ref){   // Base cases   if (root == NULL)  return NULL;    if (root->left == NULL && root->right == NULL)   {       // This node is going to be added to doubly linked list       // of leaves, set right pointer of this node as previous       // head of DLL. We don't need to set left pointer as left       // is already NULL       root->right = *head_ref;        // Change left pointer of previous head       if (*head_ref != NULL) (*head_ref)->left = root;        // Change head of linked list       *head_ref = root;        return NULL;  // Return new root   }    // Recur for right and left subtrees   root->right = extractLeafList(root->right, head_ref);   root->left  = extractLeafList(root->left, head_ref);    return root;} // Utility function for allocating node for Binary Tree.struct Node* newNode(int data){    struct Node* node = (struct Node*)malloc(sizeof(struct Node));    node->data = data;    node->left = node->right = NULL;    return node;} // Utility function for printing tree in In-Order.void print(struct Node *root){    if (root != NULL)    {         print(root->left);         printf("%d ",root->data);         print(root->right);    }} // Utility function for printing double linked list.void printList(struct Node *head){     while (head)     {         printf("%d ", head->data);         head = head->right;     }} // Driver program to test above functionint main(){     struct Node *head = NULL;     struct Node *root = newNode(1);     root->left = newNode(2);     root->right = newNode(3);     root->left->left = newNode(4);     root->left->right = newNode(5);     root->right->right = newNode(6);     root->left->left->left = newNode(7);     root->left->left->right = newNode(8);     root->right->right->left = newNode(9);     root->right->right->right = newNode(10);      printf("Inorder Traversal of given Tree is:\n");     print(root);      root = extractLeafList(root, &head);      printf("\nExtracted Double Linked list is:\n");     printList(head);      printf("\nInorder traversal of modified tree is:\n");     print(root);     return 0;}
// Java program to extract leaf nodes from binary tree// using double linked list  // A binary tree nodeclass Node{    int data;    Node left, right;      Node(int item)    {        data = item;        right = left = null;    }}  public class BinaryTree{    Node root;    Node head; // will point to head of DLL     Node prev; // temporary pointer      // The main function that links the list list to be traversed    public Node extractLeafList(Node root)    {        if (root == null)            return null;        if (root.left == null && root.right == null)        {            if (head == null)            {                head = root;                prev = root;            }            else            {                prev.right = root;                root.left = prev;                prev = root;            }            return null;        }        root.left = extractLeafList(root.left);        root.right = extractLeafList(root.right);        return root;    }      //Prints the DLL in both forward and reverse directions.    public void printDLL(Node head)    {        Node last = null;        while (head != null)        {            System.out.print(head.data + " ");            last = head;            head = head.right;        }    }      void inorder(Node node)    {        if (node == null)            return;        inorder(node.left);        System.out.print(node.data + " ");        inorder(node.right);    }      // Driver program to test above functions    public static void main(String args[])    {        BinaryTree tree = new BinaryTree();        tree.root = new Node(1);        tree.root.left = new Node(2);        tree.root.right = new Node(3);          tree.root.left.left = new Node(4);        tree.root.left.right = new Node(5);        tree.root.right.right = new Node(6);        tree.root.left.left.left = new Node(7);        tree.root.left.left.right = new Node(8);        tree.root.right.right.left = new Node(9);        tree.root.right.right.right = new Node(10);          System.out.println("Inorder traversal of given tree is : ");        tree.inorder(tree.root);        tree.extractLeafList(tree.root);        System.out.println("");        System.out.println("Extracted double link list is : ");        tree.printDLL(tree.head);        System.out.println("");        System.out.println("Inorder traversal of modified tree is : ");        tree.inorder(tree.root);    }} // This code has been contributed by Mayank Jaiswal(mayank_24)
# Python program to extract leaf nodes from binary tree# using double linked list # A binary tree nodeclass Node:         # Constructor to create a new node    def __init__(self, data):        self.data = data        self.left = None        self.right = None # Main function which extracts all leaves from given Binary Tree.# The function returns new root of Binary Tree (Note that# root may change if Binary Tree has only one node).# The function also sets *head_ref as head of doubly linked list.# left pointer of tree is used as prev in DLL# and right pointer is used as nextdef extractLeafList(root):         # Base Case    if root is None:        return None     if root.left is None and root.right is None:        # This node is going to be added to doubly linked        # list of leaves, set pointer of this node as        # previous head of DLL. We don't need to set left        # pointer as left is already None        root.right = extractLeafList.head                 # Change the left pointer of previous head        if extractLeafList.head is not None:            extractLeafList.head.left = root         # Change head of linked list        extractLeafList.head = root                 return None # Return new root     # Recur for right and left subtrees    root.right = extractLeafList(root.right)    root.left = extractLeafList(root.left)         return root # Utility function for printing tree in InOrderdef printInorder(root):    if root is not None:        printInorder(root.left)        print (root.data,end=" ")        printInorder(root.right)  def printList(head):    while(head):        if head.data is not None:            print (head.data,end=" ")        head = head.right # Driver program to test above functionextractLeafList.head = Node(None)root = Node(1)root.left = Node(2)root.right = Node(3)root.left.left = Node(4)root.left.right = Node(5)root.right.right = Node(6)root.left.left.left = Node(7)root.left.left.right = Node(8)root.right.right.left = Node(9)root.right.right.right = Node(10) print ("Inorder traversal of given tree is:")printInorder(root) root = extractLeafList(root) print ("\nExtract Double Linked List is:")printList(extractLeafList.head) print ("\nInorder traversal of modified tree is:")printInorder(root)
// C# program to extract leaf// nodes from binary tree// using double linked listusing System; // A binary tree nodepublic class Node{    public int data;    public Node left, right;     public Node(int item)    {        data = item;        right = left = null;    }} public class BinaryTree{    Node root;    Node head; // will point to head of DLL    Node prev; // temporary pointer     // The main function that links    // the list list to be traversed    public Node extractLeafList(Node root)    {        if (root == null)            return null;        if (root.left == null && root.right == null)        {            if (head == null)            {                head = root;                prev = root;            }            else            {                prev.right = root;                root.left = prev;                prev = root;            }            return null;        }        root.left = extractLeafList(root.left);        root.right = extractLeafList(root.right);        return root;    }     // Prints the DLL in both forward    // and reverse directions.    public void printDLL(Node head)    {        Node last = null;        while (head != null)        {            Console.Write(head.data + " ");            last = head;            head = head.right;        }    }     void inorder(Node node)    {        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();        tree.root = new Node(1);        tree.root.left = new Node(2);        tree.root.right = new Node(3);         tree.root.left.left = new Node(4);        tree.root.left.right = new Node(5);        tree.root.right.right = new Node(6);        tree.root.left.left.left = new Node(7);        tree.root.left.left.right = new Node(8);        tree.root.right.right.left = new Node(9);        tree.root.right.right.right = new Node(10);         Console.WriteLine("Inorder traversal of given tree is : ");        tree.inorder(tree.root);        tree.extractLeafList(tree.root);        Console.WriteLine("");        Console.WriteLine("Extracted double link list is : ");        tree.printDLL(tree.head);        Console.WriteLine("");        Console.WriteLine("Inorder traversal of modified tree is : ");        tree.inorder(tree.root);    }} // This code has been contributed by 29AjayKumar
<script>    // javascript program to extract leaf nodes from binary tree    // using var linked list     // A binary tree node    class Node {        constructor(val) {            this.data = val;            this.left = null;            this.right = null;        }    }      var root;    var head; // will point to head of DLL    var prev; // temporary pointer     // The main function that links the list list to be traversed    function extractLeafList(root) {        if (root == null)            return null;        if (root.left == null && root.right == null) {            if (head == null) {                head = root;                prev = root;            }              else {                prev.right = root;                root.left = prev;                prev = root;            }            return null;        }        root.left = extractLeafList(root.left);        root.right = extractLeafList(root.right);        return root;    }     // Prints the DLL in both forward and reverse directions.    function printDLL(head) {        var last = null;        while (head != null) {            document.write(head.data + " ");            last = head;            head = head.right;        }    }     function inorder(node) {        if (node == null)            return;        inorder(node.left);        document.write(node.data + " ");        inorder(node.right);    }     // Driver program to test above functions     root = new Node(1);    root.left = new Node(2);    root.right = new Node(3);     root.left.left = new Node(4);    root.left.right = new Node(5);    root.right.right = new Node(6);    root.left.left.left = new Node(7);    root.left.left.right = new Node(8);    root.right.right.left = new Node(9);    root.right.right.right = new Node(10);     document.write("Inorder traversal of given tree is :<br/> ");    inorder(root);    extractLeafList(root);    document.write("<br/>");    document.write("Extracted var link list is :<br/> ");    printDLL(head);    document.write("<br/>");    document.write("Inorder traversal of modified tree is : <br/>");    inorder(root); // This code contributed by umadevi9616</script>
Inorder Traversal of given Tree is:
7 4 8 2 5 1 3 9 6 10 
Extracted Double Linked list is:
7 8 5 9 10 
Inorder traversal of modified tree is:
4 2 1 3 6 
Time Complexity: O(n), the solution does a single traversal of a given Binary Tree.
YouTubeGeeksforGeeks502K subscribersExtract Leaves of a Binary Tree in a Doubly Linked List | 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 / 4:53•Live•<div class="player-unavailable"><h1 class="message">An error occurred.</h1><div class="submessage"><a href="https://www.youtube.com/watch?v=JH9Jea12MEI" 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 is contributed by Chandra Prakash. Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above. 
29AjayKumar
rathbhupendra
Akanksha_Rai
umadevi9616
simmytarika5
khushboogoyal499
sagar0719kumar
amartyaghoshgfg
Amazon
doubly linked list
Linkedin
Linked List
Tree
Amazon
Linkedin
Linked List
Tree
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Linked List | Set 1 (Introduction)
Linked List | Set 2 (Inserting a node)
Reverse a linked list
Stack Data Structure (Introduction and Program)
Linked List | Set 3 (Deleting a node)
Tree Traversals (Inorder, Preorder and Postorder)
Binary Tree | Set 1 (Introduction)
Level Order Binary Tree Traversal
AVL Tree | Set 1 (Insertion)
Inorder Tree Traversal without Recursion