# Iterative diagonal traversal of binary tree

• Difficulty Level : Medium
• Last Updated : 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 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 ` `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.*;` `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```

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

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

?list=PLqM7alHXFySHCXD7r1J0ky9Zg_GBB1dbk

My Personal Notes arrow_drop_up
Recommended Articles
Page :