Iterative diagonal traversal of binary tree

Difficulty Level : Medium
Last Updated : 31 May, 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 Tree
In 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++

/* 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 view
void 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 Code
int 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

// Java program to con string from binary tree
import java.util.*;
class solution
{
 
   
// A binary tree node has data, pointer to left
 //  child and a pointer to right child
static class Node {
    int data;
    Node left, right;
};
   
// Helper function that allocates a new node
static Node newNode(int data)
{
    Node node = new Node();
    node.data = data;
    node.left = node.right = null;
    return (node);
}
   
// Iterative function to print diagonal view
static 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 Code
public 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

# Python3 program to construct string from binary tree
class Node:
    def __init__(self,data):
        self.val = data
        self.left = None
        self.right = None
         
# Function to print diagonal view
def 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 Code
root = 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#

// C# program to con string from binary tree
using System;
using System.Collections;
 
class GFG
{
 
// A binary tree node has data,
// pointer to left child and
// a pointer to right child
public class Node
{
    public int data;
    public Node left, right;
};
     
// Helper function that
// allocates a new node
static Node newNode(int data)
{
    Node node = new Node();
    node.data = data;
    node.left = node.right = null;
    return (node);
}
     
// Iterative function to print diagonal view
static 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 Code
public 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

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

import java.util.Queue;
import java.util.LinkedList;
 
//Node
class 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 contibuted by Likhita AVL

Output

8 10 14 3 6 7 13 1 4

?list=PLqM7alHXFySHCXD7r1J0ky9Zg_GBB1dbk

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready. To complete your preparation from learning a language to DS Algo and many more, please refer Complete Interview Preparation Course.

In case you wish to attend live classes with industry experts, please refer DSA Live Classes

My Personal Notes

Related Articles

C++

Java

Python3

C#

Java