# Iterative diagonal traversal of binary tree

• Difficulty Level : Medium
• Last Updated : 26 Dec, 2022

Consider lines of slope -1 passing between nodes. Given a Binary Tree, print all diagonal elements in a binary tree belonging to the 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 the recursive solution in the below post.
Diagonal Traversal of Binary Tree
In this post, an iterative solution is discussed. The idea is to use a queue to store only the left child of the current node. After printing the data of the current node make the current node to its right child if present.
A delimiter NULL is used to mark the starting of the next diagonal.

Below is the implementation of the above approach.

## C++

 `/* C++ program to construct string from binary tree*/``#include ``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 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.*;``public` `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 q= ``new` `LinkedList();``  ` `    ``// 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`

## Javascript

 ``

Output

```8 10 14
3 6 7 13
1 4 ```

Time Complexity: O(n), where n is the total number of nodes in the binary tree.
Auxiliary Space: O(n),  As we use a queue to store the nodes, the space complexity is also O(n).

Method: Without using a 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:

## C++

 `/* C++ program to print the diagonal traversal of binary`` ``* tree*/``#include ``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);``}``// root node``Node* root;` `// 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 q;` `    ``// continue till the queue is empty and curr is null``    ``while` `(!q.empty() || curr != NULL) {``        ``// if curr is not 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) {``            ``cout << 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.front();``            ``q.pop();``        ``}``    ``}``}` `// Driver Code``int` `main()``{``    ``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);``    ``traverse();``}` `// This code is contributed by Abhijeet Kumar(abhijeet19403)`

## 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 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`

## Python3

 `# Python3 program to print the diagonal traversal of binary tree` `class` `Node:``    ``def` `__init__(``self``, data):``        ``self``.data ``=` `data``        ``self``.left ``=` `None``        ``self``.right ``=` `None` `#root node``root``=``Node(``0``)` `# function to print in diagonal order``def` `traverse():``    ``# if the tree is empty, do not have to print``    ``# anything``    ``if` `root ``is` `None``:``        ``return` `    ``# if root is not empty, point curr node to the``    ``# root node``    ``curr ``=` `root` `    ``# Maintain a queue to store left child``    ``q ``=` `[]` `    ``# continue till the queue is empty and curr is null``    ``while``(``len``(q)!``=``0` `or`  `curr !``=` `None``):``            ``# if curr is not 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 !``=` `None``):``            ``print``(curr.data,end``=``" "``)` `            ``if``(curr.left !``=` `None``):``                ``q.append(curr.left)``            ``curr ``=` `curr.right``            ``# if curr is null, remove a node from the queue``            ``# and point it to curr node``        ``else``:``            ``curr ``=` `q.pop(``0``)`  `# 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``)``traverse()` `# This code is contributed by Abhijeet Kumar(abhijeet19403)`

## C#

 `using` `System;``using` `System.Collections.Generic;` `// Node``public` `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 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 q = ``new` `Queue();``     ` `    ``// 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 code``static` `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`

## Javascript

 ``

Output

`8 10 14 3 6 7 13 1 4 `

Time Complexity: O(n), As we are traversing every element only once.
Auxiliary Space: O(n), Extra space is used to store the elements in the queue.

?list=PLqM7alHXFySHCXD7r1J0ky9Zg_GBB1dbk

My Personal Notes arrow_drop_up