Iterative diagonal traversal of binary tree - GeeksforGeeks

23 Aug, 2021
Consider lines of slope -1 passing between nodes. Given a Binary Tree, print all diagonal elements in a binary tree belonging to same line.
Input : Root of below tree
Output : 
Diagonal Traversal of binary tree : 
 8 10 14
 3 6 7 13
 1 4
We have discussed recursive solution in below post.Diagonal Traversal of Binary TreeIn this post, iterative solution is discussed. The idea is to use a queue to store only the left child of current node. After printing the data of current node make the current node to its right child, if present. A delimiter NULL is used to mark the starting of next diagonal.
Below is the implementation of above approach.  
C++
Java
Python3
C#
Javascript
/* C++ program to construct string from binary tree*/#include <bits/stdc++.h>using namespace std; /* A binary tree node has data, pointer to left   child and a pointer to right child */struct Node {    int data;    Node *left, *right;}; /* Helper function that allocates a new node */Node* newNode(int data){    Node* node = (Node*)malloc(sizeof(Node));    node->data = data;    node->left = node->right = NULL;    return (node);} // Iterative function to print diagonal viewvoid diagonalPrint(Node* root){    // base case    if (root == NULL)        return;     // inbuilt queue of Treenode    queue<Node*> q;     // push root    q.push(root);     // push delimiter    q.push(NULL);     while (!q.empty()) {        Node* temp = q.front();        q.pop();         // if current is delimiter then insert another        // for next diagonal and cout nextline        if (temp == NULL) {             // if queue is empty return            if (q.empty())                return;             // output nextline            cout << endl;             // push delimiter again            q.push(NULL);        }        else {            while (temp) {                cout << temp->data << " ";                 // if left child is present                // push into queue                if (temp->left)                    q.push(temp->left);                 // current equals to right child                temp = temp->right;            }        }    }} // Driver Codeint main(){    Node* root = newNode(8);    root->left = newNode(3);    root->right = newNode(10);    root->left->left = newNode(1);    root->left->right = newNode(6);    root->right->right = newNode(14);    root->right->right->left = newNode(13);    root->left->right->left = newNode(4);    root->left->right->right = newNode(7);    diagonalPrint(root);}
// Java program to con string from binary treeimport java.util.*;class solution{    // A binary tree node has data, pointer to left //  child and a pointer to right childstatic class Node {    int data;    Node left, right;};   // Helper function that allocates a new nodestatic Node newNode(int data){    Node node = new Node();    node.data = data;    node.left = node.right = null;    return (node);}   // Iterative function to print diagonal viewstatic void diagonalPrint(Node root){    // base case    if (root == null)        return;       // inbuilt queue of Treenode    Queue<Node> q= new LinkedList<Node>();       // add root    q.add(root);       // add delimiter    q.add(null);       while (q.size()>0) {        Node temp = q.peek();        q.remove();           // if current is delimiter then insert another        // for next diagonal and cout nextline        if (temp == null) {               // if queue is empty return            if (q.size()==0)                return;               // output nextline            System.out.println();               // add delimiter again            q.add(null);        }        else {            while (temp!=null) {                System.out.print( temp.data + " ");                   // if left child is present                 // add into queue                if (temp.left!=null)                    q.add(temp.left);                   // current equals to right child                temp = temp.right;            }        }    }}   // Driver Codepublic static void main(String args[]){    Node root = newNode(8);    root.left = newNode(3);    root.right = newNode(10);    root.left.left = newNode(1);    root.left.right = newNode(6);    root.right.right = newNode(14);    root.right.right.left = newNode(13);    root.left.right.left = newNode(4);    root.left.right.right = newNode(7);    diagonalPrint(root);}}//contributed by Arnab Kundu
# Python3 program to construct string from binary treeclass Node:    def __init__(self,data):        self.val = data        self.left = None        self.right = None         # Function to print diagonal viewdef diagonalprint(root):         # base case    if root is None:        return             # queue of treenode    q = []         # Append root    q.append(root)         # Append delimiter    q.append(None)     while len(q) > 0:        temp = q.pop(0)                 # If current is delimiter then insert another        # for next diagonal and cout nextline        if not temp:                         # If queue is empty then return            if len(q) == 0:                return                             # Print output on nextline            print(' ')                         # append delimiter again            q.append(None)         else:            while temp:                print(temp.val, end = ' ')                                 # If left child is present                # append into queue                if temp.left:                    q.append(temp.left)                                     # current equals to right child                temp = temp.right # Driver Coderoot = Node(8)root.left = Node(3)root.right = Node(10)root.left.left = Node(1)root.left.right = Node(6)root.right.right = Node(14)root.right.right.left = Node(13)root.left.right.left = Node(4)root.left.right.right = Node(7)diagonalprint(root) # This code is contributed by Praveen kumar
// C# program to con string from binary treeusing System;using System.Collections; class GFG{ // A binary tree node has data,// pointer to left child and// a pointer to right childpublic class Node{    public int data;    public Node left, right;};     // Helper function that// allocates a new nodestatic Node newNode(int data){    Node node = new Node();    node.data = data;    node.left = node.right = null;    return (node);}     // Iterative function to print diagonal viewstatic void diagonalPrint(Node root){    // base case    if (root == null)        return;         // inbuilt queue of Treenode    Queue q = new Queue();         // Enqueue root    q.Enqueue(root);         // Enqueue delimiter    q.Enqueue(null);         while (q.Count > 0)    {        Node temp = (Node) q.Peek();        q.Dequeue();             // if current is delimiter then insert another        // for next diagonal and cout nextline        if (temp == null)        {                 // if queue is empty return            if (q.Count == 0)                return;                 // output nextline            Console.WriteLine();                 // Enqueue delimiter again            q.Enqueue(null);        }        else        {            while (temp != null)            {                Console.Write( temp.data + " ");                     // if left child is present                // Enqueue into queue                if (temp.left != null)                    q.Enqueue(temp.left);                     // current equals to right child                temp = temp.right;            }        }    }}     // Driver Codepublic static void Main(String []args){    Node root = newNode(8);    root.left = newNode(3);    root.right = newNode(10);    root.left.left = newNode(1);    root.left.right = newNode(6);    root.right.right = newNode(14);    root.right.right.left = newNode(13);    root.left.right.left = newNode(4);    root.left.right.right = newNode(7);    diagonalPrint(root);}} // This code is contributed by Arnab Kundu
<script>     // JavaScript program to con string from binary tree         class Node    {        constructor(data) {           this.left = null;           this.right = null;           this.data = data;        }    }     // Helper function that allocates a new node    function newNode(data)    {        let node = new Node(data);        return (node);    }     // Iterative function to print diagonal view    function diagonalPrint(root)    {        // base case        if (root == null)            return;         // inbuilt queue of Treenode        let q= [];         // add root        q.push(root);         // add delimiter        q.push(null);         while (q.length>0) {            let temp = q[0];            q.shift();             // if current is delimiter then insert another            // for next diagonal and cout nextline            if (temp == null) {                 // if queue is empty return                if (q.length==0)                    return;                 // output nextline                document.write("</br>");                 // add delimiter again                q.push(null);            }            else {                while (temp!=null) {                    document.write( temp.data + " ");                     // if left child is present                    // add into queue                    if (temp.left!=null)                        q.push(temp.left);                     // current equals to right child                    temp = temp.right;                }            }        }    }         let root = newNode(8);    root.left = newNode(3);    root.right = newNode(10);    root.left.left = newNode(1);    root.left.right = newNode(6);    root.right.right = newNode(14);    root.right.right.left = newNode(13);    root.left.right.left = newNode(4);    root.left.right.right = newNode(7);    diagonalPrint(root); </script>
Output:  
8 10 14 
3 6 7 13 
1 4
Method: Without using delimiter
Just like level order traversal, use a queue. Little modification is to be done. 
if(curr.left != null) -> add it to the queue
and move curr pointer to right of curr.

if curr = null, then remove a node from queue.
Implementation:
Java
C#
Javascript
import java.util.Queue;import java.util.LinkedList; //Nodeclass Node{    int data;    Node left;    Node right;         //Constructor for initializing the value of the node along with    //left and right pointers    Node(int data){        this.data = data;        left = right = null;    }} public class DiagonalTraversal {    //root node    Node root = null;         //function to print in diagonal order    void traverse() {        //if the tree is empty, do not have to print        //anything        if(root == null)            return;                 //if root is not empty, point curr node to the        //root node        Node curr = root;                 //Maintain a queue to store left child        Queue<Node> q = new LinkedList<>();                 //continue till the queue is empty and curr is null        while(!q.isEmpty()  ||  curr!=null) {            //if curr is null            //1. print the data of the curr node            //2. if left child is present, add it to the queue            //3. Move curr pointer to the right            if(curr != null) {                System.out.print(curr.data+" ");                                 if(curr.left != null)                    q.add(curr.left);                curr = curr.right;            }            //if curr is null, remove a node from the queue            //and point it to curr node            else {                curr = q.remove();            }        }    }         //Driver function    public static void main(String args[]) {        DiagonalTraversal tree = new DiagonalTraversal();/*                 8               /  \              3    10             / \    \            1   6     14               / \    /              4   7  13            */                 //construction of the tree        tree.root = new Node(8);        tree.root.left = new Node(3);        tree.root.right = new Node(10);        tree.root.left.left = new Node(1);        tree.root.left.right = new Node(6);        tree.root.right.right = new Node(14);        tree.root.right.right.left = new Node(13);        tree.root.left.right.left = new Node(4);        tree.root.left.right.right = new Node(7);                 //function call        tree.traverse();    }} //This method is contributed by Likhita AVL
using System;using System.Collections.Generic; // Nodepublic class Node{    public int data;    public Node left;    public Node right;          // Constructor for initializing the value    // of the node along with left and right pointers    public Node(int data)    {        this.data = data;        left = right = null;    }} public class DiagonalTraversal{ // Root nodeNode root = null;  // Function to print in diagonal ordervoid traverse(){         // If the tree is empty, do not have to print    // anything    if (root == null)        return;          // If root is not empty, point curr node to the    // root node    Node curr = root;          // Maintain a queue to store left child    Queue<Node> q = new Queue<Node>();          // Continue till the queue is empty    // and curr is null    while (q.Count != 0 || curr != null)    {                 // If curr is null        // 1. print the data of the curr node        // 2. if left child is present, add it to the queue        // 3. Move curr pointer to the right        if (curr != null)        {            Console.Write(curr.data + " ");                          if (curr.left != null)                q.Enqueue(curr.left);                             curr = curr.right;        }                 // If curr is null, remove a node from        // the queue and point it to curr node        else        {            curr = q.Dequeue();        }    }} // Driver codestatic public void Main(){         DiagonalTraversal tree = new DiagonalTraversal();    /*       8           /  \          3    10         / \    \        1   6     14           / \    /          4   7  13            */          // Construction of the tree    tree.root = new Node(8);    tree.root.left = new Node(3);    tree.root.right = new Node(10);    tree.root.left.left = new Node(1);    tree.root.left.right = new Node(6);    tree.root.right.right = new Node(14);    tree.root.right.right.left = new Node(13);    tree.root.left.right.left = new Node(4);    tree.root.left.right.right = new Node(7);          // Function call    tree.traverse();}} // This code is contributed by rag2127
<script> //Nodeclass Node{    // Constructor for initializing the value of the node along with    // left and right pointers    constructor(data)    {        this.data = data;        this.left = this.right = null;    }} // root nodelet root = null; // function to print in diagonal orderfunction traverse(){    // if the tree is empty, do not have to print        // anything        if(root == null)            return;                  // if root is not empty, point curr node to the        // root node        let curr = root;                  // Maintain a queue to store left child        let q = [];                  // continue till the queue is empty and curr is null        while(q.length!=0  ||  curr!=null) {            // if curr is null            // 1. print the data of the curr node            // 2. if left child is present, add it to the queue            // 3. Move curr pointer to the right            if(curr != null) {                document.write(curr.data+" ");                                  if(curr.left != null)                    q.push(curr.left);                curr = curr.right;            }            // if curr is null, remove a node from the queue            // and point it to curr node            else {                curr = q.shift();            }       }} // Driver function /*               8               /  \              3    10             / \    \            1   6     14               / \    /              4   7  13            */ //construction of the treeroot = new Node(8);root.left = new Node(3);root.right = new Node(10);root.left.left = new Node(1);root.left.right = new Node(6);root.right.right = new Node(14);root.right.right.left = new Node(13);root.left.right.left = new Node(4);root.left.right.right = new Node(7); // function calltraverse();  // This code is contributed by avanitrachhadiya2155 </script>
8 10 14 3 6 7 13 1 4 
YouTubeGeeksforGeeks501K subscribersIterative diagonal traversal of binary tree | 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:34•Live•<div class="player-unavailable"><h1 class="message">An error occurred.</h1><div class="submessage"><a href="https://www.youtube.com/watch?v=vd6Ly5rGBo0" target="_blank">Try watching this video on www.youtube.com</a>, or enable JavaScript if it is disabled in your browser.</div></div>
?list=PLqM7alHXFySHCXD7r1J0ky9Zg_GBB1dbk 
andrew1234
mepky
avllikhita
rameshtravel07
avanitrachhadiya2155
rag2127
kk773572498
cpp-queue
Tree
Tree
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Comments
Old Comments
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
Binary Tree | Set 3 (Types of Binary Tree)
Write a Program to Find the Maximum Depth or Height of a Tree
Binary Tree | Set 2 (Properties)
Decision Tree
A program to check if a binary tree is BST or not