Convert a Binary Tree into Doubly Linked List in spiral fashion - GeeksforGeeks

02 Mar, 2022
Given a Binary Tree, convert it into Doubly Linked List where the nodes are represented Spirally. The left pointer of the binary tree node should act as a previous node for created DLL and right pointer should act as next node. The solution should not allocate extra memory for DLL nodes. It should use binary tree nodes for creating DLL i.e. only change of pointers is allowed  
For example, for the tree on left side, Doubly Linked List can be,1 2 3 7 6 5 4 8 9 10 11 13 14 or1 3 2 4 5 6 7 14 13 11 10 9 8.We strongly recommend you to minimize your browser and try this yourself first.We can do this by doing a spiral order traversal in O(n) time and O(n) extra space. The idea is to use deque (Double-ended queue) that can be expanded or contracted on both ends (either its front or its back). We do something similar to level order traversal but to maintain spiral order, for every odd level, we dequeue node from the front and inserts its left and right children in the back of the deque data structure. And for each even level, we dequeue node from the back and inserts its right and left children in the front of deque. We also maintain a stack to store Binary Tree nodes. Whenever we pop nodes from deque, we push that node into stack. Later, we pop all nodes from stack and push the nodes in the beginning of the list. We can avoid use of stack if we maintain a tail pointer that always points to last node of DLL and inserts nodes in O(1) time in the end.Below is the implementation of above idea  
C++
Java
Python3
C#
Javascript
/* c++ program to convert Binary Tree into Doubly   Linked List where the nodes are represented   spirally. */#include <bits/stdc++.h>using namespace std; // A Binary Tree Nodestruct Node{    int data;    struct Node *left, *right;}; /* Given a reference to the head of a list and a node,inserts the node on the front of the list. */void push(Node** head_ref, Node* node){    // Make right of given node as head and left as    // NULL    node->right = (*head_ref);    node->left = NULL;     // change left of head node to given node    if ((*head_ref) !=  NULL)        (*head_ref)->left = node ;     // move the head to point to the given node    (*head_ref) = node;} // Function to prints contents of DLLvoid printList(Node *node){    while (node != NULL)    {        cout << node->data << " ";        node = node->right;    }} /* Function to print corner node at each level */void spiralLevelOrder(Node *root){    // Base Case    if (root == NULL)        return;     // Create an empty deque for doing spiral    // level order traversal and enqueue root    deque<Node*> q;    q.push_front(root);     // create a stack to store Binary Tree nodes    // to insert into DLL later    stack<Node*> stk;     int level = 0;    while (!q.empty())    {        // nodeCount indicates number of Nodes        // at current level.        int nodeCount = q.size();         // Dequeue all Nodes of current level and        // Enqueue all Nodes of next level        if (level&1)    //odd level        {            while (nodeCount > 0)            {                // dequeue node from front & push it to                // stack                Node *node = q.front();                q.pop_front();                stk.push(node);                 // insert its left and right children                // in the back of the deque                if (node->left != NULL)                    q.push_back(node->left);                if (node->right != NULL)                    q.push_back(node->right);                 nodeCount--;            }        }        else      //even level        {            while (nodeCount > 0)            {                // dequeue node from the back & push it                // to stack                Node *node = q.back();                q.pop_back();                stk.push(node);                 // inserts its right and left children                // in the front of the deque                if (node->right != NULL)                    q.push_front(node->right);                if (node->left != NULL)                    q.push_front(node->left);                nodeCount--;            }        }        level++;    }     // head pointer for DLL    Node* head = NULL;     // pop all nodes from stack and    // push them in the beginning of the list    while (!stk.empty())    {        push(&head, stk.top());        stk.pop();    }     cout << "Created DLL is:\n";    printList(head);} // Utility function to create a new tree NodeNode* newNode(int data){    Node *temp = new Node;    temp->data = data;    temp->left = temp->right = NULL;     return temp;} // Driver program to test above functionsint main(){    // Let us create binary tree shown in above diagram    Node *root =  newNode(1);    root->left = newNode(2);    root->right = newNode(3);    root->left->left = newNode(4);    root->left->right = newNode(5);    root->right->left = newNode(6);    root->right->right = newNode(7);     root->left->left->left  = newNode(8);    root->left->left->right  = newNode(9);    root->left->right->left  = newNode(10);    root->left->right->right  = newNode(11);    //root->right->left->left  = newNode(12);    root->right->left->right  = newNode(13);    root->right->right->left  = newNode(14);    //root->right->right->right  = newNode(15);     spiralLevelOrder(root);     return 0;}
/* Java program to convert Binary Tree into Doubly Linked List   where the nodes are represented spirally */ import java.util.*; // A binary tree nodeclass Node{    int data;    Node left, right;     public Node(int data)    {        this.data = data;        left = right = null;    }} class BinaryTree{    Node root;    Node head;     /* Given a reference to a node,       inserts the node on the front of the list. */    void push(Node node)    {        // Make right of given node as head and left as        // NULL        node.right = head;        node.left = null;         // change left of head node to given node        if (head != null)            head.left = node;                     // move the head to point to the given node        head = node;    }     // Function to prints contents of DLL    void printList(Node node)    {        while (node != null)        {            System.out.print(node.data + " ");            node = node.right;        }    }     /* Function to print corner node at each level */    void spiralLevelOrder(Node root)    {        // Base Case        if (root == null)            return;         // Create an empty deque for doing spiral        // level order traversal and enqueue root        Deque<Node> q = new LinkedList<Node>();        q.addFirst(root);         // create a stack to store Binary Tree nodes        // to insert into DLL later        Stack<Node> stk = new Stack<Node>();         int level = 0;        while (!q.isEmpty())        {            // nodeCount indicates number of Nodes            // at current level.            int nodeCount = q.size();             // Dequeue all Nodes of current level and            // Enqueue all Nodes of next level            if ((level & 1) %2 != 0) //odd level            {                while (nodeCount > 0)                {                    // dequeue node from front & push it to                    // stack                    Node node = q.peekFirst();                    q.pollFirst();                    stk.push(node);                     // insert its left and right children                    // in the back of the deque                    if (node.left != null)                        q.addLast(node.left);                    if (node.right != null)                        q.addLast(node.right);                     nodeCount--;                }            }            else //even level            {                while (nodeCount > 0)                {                    // dequeue node from the back & push it                    // to stack                    Node node = q.peekLast();                    q.pollLast();                    stk.push(node);                     // inserts its right and left children                    // in the front of the deque                    if (node.right != null)                        q.addFirst(node.right);                    if (node.left != null)                        q.addFirst(node.left);                    nodeCount--;                }            }            level++;        }         // pop all nodes from stack and        // push them in the beginning of the list        while (!stk.empty())        {            push(stk.peek());            stk.pop();        }         System.out.println("Created DLL is : ");        printList(head);    }     // Driver program to test above functions    public static void main(String[] args)    {        // Let us create binary tree as shown in above diagram        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.left = new Node(6);        tree.root.right.right = new Node(7);         tree.root.left.left.left = new Node(8);        tree.root.left.left.right = new Node(9);        tree.root.left.right.left = new Node(10);        tree.root.left.right.right = new Node(11);        // tree.root.right.left.left = new Node(12);        tree.root.right.left.right = new Node(13);        tree.root.right.right.left = new Node(14);        // tree.root.right.right.right = new Node(15);         tree.spiralLevelOrder(tree.root);    }} // This code has been contributed by Mayank Jaiswal(mayank_24)
# Python3 program to convert Binary Tree# into Doubly Linked List where the nodes# are represented spirally.     # Binary tree nodeclass newNode:     # Constructor to create a newNode    def __init__(self, data):        self.data = data        self.left = None        self.right = None         """ Given a reference to the head of a list    and a node, inserts the node on the front    of the list. """def push(head_ref, node):     # Make right of given node as    # head and left as None    node.right = (head_ref)    node.left = None     # change left of head node to    # given node    if ((head_ref) != None):        (head_ref).left = node     # move the head to point to    # the given node    (head_ref) = node # Function to prints contents of DLLdef printList(node):    i = 0    while (i < len(node)):             print(node[i].data, end = " ")        i += 1     """ Function to print corner node at each level """def spiralLevelOrder(root):     # Base Case    if (root == None):        return     # Create an empty deque for doing spiral    # level order traversal and enqueue root    q = []    q.append(root)     # create a stack to store Binary    # Tree nodes to insert into DLL later    stk = []     level = 0    while (len(q)):             # nodeCount indicates number of        # Nodes at current level.        nodeCount = len(q)                 # Dequeue all Nodes of current level        # and Enqueue all Nodes of next level        if (level&1): # odd level            while (nodeCount > 0):                             # dequeue node from front &                # push it to stack                node = q[0]                q.pop(0)                stk.append(node)                 # insert its left and right children                # in the back of the deque                if (node.left != None):                    q.append(node.left)                if (node.right != None):                    q.append(node.right)                 nodeCount -= 1                     else:     # even level                     while (nodeCount > 0):                             # dequeue node from the back &                # push it to stack                node = q[-1]                q.pop(-1)                stk.append(node)                 # inserts its right and left                # children in the front of                # the deque                if (node.right != None):                    q.insert(0, node.right)                if (node.left != None):                    q.insert(0, node.left)                nodeCount -= 1        level += 1             # head pointer for DLL    head = []         # pop all nodes from stack and push    # them in the beginning of the list    while (len(stk)):             head.append(stk[0])        stk.pop(0)     print("Created DLL is:")    printList(head) # Driver Codeif __name__ == '__main__':         """Let us create Binary Tree as    shown in above example """     root = newNode(1)    root.left = newNode(2)    root.right = newNode(3)    root.left.left = newNode(4)    root.left.right = newNode(5)    root.right.left = newNode(6)    root.right.right = newNode(7)     root.left.left.left = newNode(8)    root.left.left.right = newNode(9)    root.left.right.left = newNode(10)    root.left.right.right = newNode(11)    #root.right.left.left = newNode(12)    root.right.left.right = newNode(13)    root.right.right.left = newNode(14)    #root.right.right.right = newNode(15)     spiralLevelOrder(root) # This code is contributed# by SHUBHAMSINGH10
/* C# program to convert Binary Tree into Doubly Linked Listwhere the nodes are represented spirally */using System;using System.Collections.Generic; // A binary tree nodepublic class Node{    public int data;    public Node left, right;     public Node(int data)    {        this.data = data;        left = right = null;    }} public class BinaryTree{    Node root;    Node head;     /* Given a reference to a node,    inserts the node on the front of the list. */    void push(Node node)    {        // Make right of given node as head and left as        // NULL        node.right = head;        node.left = null;         // change left of head node to given node        if (head != null)            head.left = node;                     // move the head to point to the given node        head = node;    }     // Function to prints contents of DLL    void printList(Node node)    {        while (node != null)        {            Console.Write(node.data + " ");            node = node.right;        }    }     /* Function to print corner node at each level */    void spiralLevelOrder(Node root)    {        // Base Case        if (root == null)            return;         // Create an empty deque for doing spiral        // level order traversal and enqueue root        LinkedList<Node> q = new LinkedList<Node>();        q.AddFirst(root);         // create a stack to store Binary Tree nodes        // to insert into DLL later        Stack<Node> stk = new Stack<Node>();         int level = 0;        while (q.Count != 0)        {            // nodeCount indicates number of Nodes            // at current level.            int nodeCount = q.Count;             // Dequeue all Nodes of current level and            // Enqueue all Nodes of next level            if ((level & 1) % 2 != 0) //odd level            {                while (nodeCount > 0)                {                    // dequeue node from front & push it to                    // stack                    Node node = q.First.Value;                    q.RemoveFirst();                    stk.Push(node);                     // insert its left and right children                    // in the back of the deque                    if (node.left != null)                        q.AddLast(node.left);                    if (node.right != null)                        q.AddLast(node.right);                     nodeCount--;                }            }            else //even level            {                while (nodeCount > 0)                {                    // dequeue node from the back & push it                    // to stack                    Node node = q.Last.Value;                    q.RemoveLast();                    stk.Push(node);                     // inserts its right and left children                    // in the front of the deque                    if (node.right != null)                        q.AddFirst(node.right);                    if (node.left != null)                        q.AddFirst(node.left);                    nodeCount--;                }            }            level++;        }         // pop all nodes from stack and        // push them in the beginning of the list        while (stk.Count != 0)        {            push(stk.Peek());            stk.Pop();        }         Console.WriteLine("Created DLL is : ");        printList(head);    }     // Driver program to test above functions    public static void Main(String[] args)    {        // Let us create binary tree as shown in above diagram        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.left = new Node(6);        tree.root.right.right = new Node(7);         tree.root.left.left.left = new Node(8);        tree.root.left.left.right = new Node(9);        tree.root.left.right.left = new Node(10);        tree.root.left.right.right = new Node(11);        // tree.root.right.left.left = new Node(12);        tree.root.right.left.right = new Node(13);        tree.root.right.right.left = new Node(14);        // tree.root.right.right.right = new Node(15);         tree.spiralLevelOrder(tree.root);    }} /* This code contributed by PrinciRaj1992 */
<script>  /* Javascript program to convert Binary Tree into Doubly Linked Listwhere the nodes are represented spirally */ // A binary tree nodeclass Node{  constructor(data)  {      this.data = data;      this.left = null;      this.right = null;  }} var root = null;var head = null;/* Given a reference to a node,inserts the node on the front of the list. */function push(node){    // Make right of given node as head and left as    // NULL    node.right = head;    node.left = null;    // change left of head node to given node    if (head != null)        head.left = node;             // move the head to point to the given node    head = node;}// Function to prints contents of DLLfunction printList(node){    while (node != null)    {        document.write(node.data + " ");        node = node.right;    }}/* Function to print corner node at each level */function spiralLevelOrder(root){    // Base Case    if (root == null)        return;    // Create an empty deque for doing spiral    // level order traversal and enqueue root    var q = [];    q.unshift(root);    // create a stack to store Binary Tree nodes    // to insert into DLL later    var stk = [];    var level = 0;    while (q.length != 0)    {        // nodeCount indicates number of Nodes        // at current level.        var nodeCount = q.length;        // Dequeue all Nodes of current level and        // Enqueue all Nodes of next level        if ((level & 1) % 2 != 0) //odd level        {            while (nodeCount > 0)            {                // dequeue node from front & push it to                // stack                var node = q[0];                q.shift();                stk.push(node);                // insert its left and right children                // in the back of the deque                if (node.left != null)                    q.push(node.left);                if (node.right != null)                    q.push(node.right);                nodeCount--;            }        }        else //even level        {            while (nodeCount > 0)            {                // dequeue node from the back & push it                // to stack                var node = q[q.length-1];                q.pop();                stk.push(node);                // inserts its right and left children                // in the front of the deque                if (node.right != null)                    q.unshift(node.right);                if (node.left != null)                    q.unshift(node.left);                nodeCount--;            }        }        level++;    }    // pop all nodes from stack and    // push them in the beginning of the list    while (stk.length != 0)    {        push(stk[stk.length-1]);        stk.pop();    }    document.write("Created DLL is :<br>");    printList(head);} // Driver program to test above functions// Let us create binary tree as shown in above diagramroot = 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.left = new Node(6);root.right.right = new Node(7);root.left.left.left = new Node(8);root.left.left.right = new Node(9);root.left.right.left = new Node(10);root.left.right.right = new Node(11);// tree.root.right.left.left = new Node(12);root.right.left.right = new Node(13);root.right.right.left = new Node(14);// tree.root.right.right.right = new Node(15);spiralLevelOrder(root); // This code is contributed by itsok. </script>
Output : 
Created DLL is:
1 2 3 7 6 5 4 8 9 10 11 13 14 
 
YouTubeGeeksforGeeks506K subscribersConvert a Binary Tree into Doubly Linked List in spiral fashion | 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 / 6:08•Live•<div class="player-unavailable"><h1 class="message">An error occurred.</h1><div class="submessage"><a href="https://www.youtube.com/watch?v=aYWzBYa_QxI" 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 Aditya Goel. If you like GeeksforGeeks and would like to contribute, you can also write an article and mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above 
SHUBHAMSINGH10
princiraj1992
itsok
surinderdawra388
doubly linked list
spiral
Tree
Tree
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
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)
Inorder Tree Traversal without Recursion
Binary Tree | Set 2 (Properties)
Write a Program to Find the Maximum Depth or Height of a Tree
Decision Tree
A program to check if a binary tree is BST or not