# Diagonal Traversal of Binary Tree

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

## Recommended: Please solve it on “PRACTICE” first, before moving on to the solution.

The idea is to use map. We use different slope distances and use them as key in map. Value in map is vector (or dynamic array) of nodes. We traverse the tree to store values in map. Once map is built, we print contents of it.

Below is C++ implementation of above idea.

## C++

```// C++ program for diagnoal traversal of Binary Tree
#include <bits/stdc++.h>
using namespace std;

// Tree node
struct Node
{
int data;
Node *left, *right;
};

/* root - root of the binary tree
d -  distance of current line from rightmost
-topmost slope.
diagonalPrint - multimap to store Diagonal
elements (Passed by Reference) */
void diagonalPrintUtil(Node* root, int d,
map<int, vector<int>> &diagonalPrint)
{
// Base case
if (!root)
return;

// Store all nodes of same line together as a vector
diagonalPrint[d].push_back(root->data);

// Increase the vertical distance if left child
diagonalPrintUtil(root->left, d + 1, diagonalPrint);

// Vertical distance remains same for right child
diagonalPrintUtil(root->right, d, diagonalPrint);
}

// Print diagonal traversal of given binary tree
void diagonalPrint(Node* root)
{
// create a map of vectors to store Diagonal elements
map<int, vector<int> > diagonalPrint;
diagonalPrintUtil(root, 0, diagonalPrint);

cout << "Diagonal Traversal of binary tree : n";
for (auto it = diagonalPrint.begin();
it != diagonalPrint.end(); ++it)
{
for (auto itr = it->second.begin();
itr != it->second.end(); ++itr)
cout << *itr  << ' ';

cout << 'n';
}
}

// Utility method to create a new node
Node* newNode(int data)
{
Node* node = new Node;
node->data = data;
node->left = node->right = NULL;
return node;
}

// Driver program
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);

/*  Node* root = newNode(1);
root->left = newNode(2);
root->right = newNode(3);
root->left->left = newNode(9);
root->left->right = newNode(6);
root->right->left = newNode(4);
root->right->right = newNode(5);
root->right->left->right = newNode(7);
root->right->left->left = newNode(12);
root->left->right->left = newNode(11);
root->left->left->right = newNode(10);*/

diagonalPrint(root);

return 0;
}
```

## Java

```// Java program for diagonal traversal of Binary Tree
import java.util.HashMap;
import java.util.Map.Entry;
import java.util.Vector;

public class DiagonalTraversalBTree
{
// Tree node
static class Node{
int data;
Node left;
Node right;

//constructor
Node(int data)
{
this.data=data;
left = null;
right =null;
}
}

/* root - root of the binary tree
d -  distance of current line from rightmost
-topmost slope.
diagonalPrint - HashMap to store Diagonal
elements (Passed by Reference) */
static void diagonalPrintUtil(Node root,int d,
HashMap<Integer,Vector<Integer>> diagonalPrint){

// Base case
if (root == null)
return;

// get the list at the particular d value
Vector<Integer> k = diagonalPrint.get(d);

// k is null then create a vector and store the data
if (k == null)
{
k = new Vector<>();
}

// k is not null then update the list
else
{
}

// Store all nodes of same line together as a vector
diagonalPrint.put(d,k);

// Increase the vertical distance if left child
diagonalPrintUtil(root.left, d + 1, diagonalPrint);

// Vertical distance remains same for right child
diagonalPrintUtil(root.right, d, diagonalPrint);
}

// Print diagonal traversal of given binary tree
static void diagonalPrint(Node root)
{
// create a map of vectors to store Diagonal elements
HashMap<Integer,Vector<Integer>> diagonalPrint = new HashMap<>();
diagonalPrintUtil(root, 0, diagonalPrint);

System.out.println("Diagonal Traversal of Binnary Tree");
for (Entry<Integer, Vector<Integer>> entry : diagonalPrint.entrySet())
{
System.out.println(entry.getValue());
}
}

// Driver program
public static void main(String[] args) {

Node root = 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);

diagonalPrint(root);
}
}
// This code is contributed by Sumit Ghosh
```

## Python

```
# Python program for diagonal traversal of Binary Tree

# A binary tree node
class Node:

# Constructor to create a new binary tree node
def __init__(self, data):
self.data = data
self.left = None
self.right = None

""" root - root of the binary tree
d -  distance of current line from rightmost
-topmost slope.
diagonalPrint - multimap to store Diagonal
elements (Passed by Reference) """
def diagonalPrintUtil(root, d, diagonalPrintMap):

# Base Case
if root is None:
return

# Store all nodes of same line together as a vector
try :
diagonalPrintMap[d].append(root.data)
except KeyError:
diagonalPrintMap[d] = [root.data]

# Increase the vertical distance if left child
diagonalPrintUtil(root.left, d+1, diagonalPrintMap)

# Vertical distance remains same for right child
diagonalPrintUtil(root.right, d, diagonalPrintMap)

# Print diagonal traversal of given binary tree
def diagonalPrint(root):

# Create a dict to store diagnoal elements
diagonalPrintMap = dict()

# Find the diagonal traversal
diagonalPrintUtil(root, 0, diagonalPrintMap)

print "Diagonal Traversal of binary tree : "
for i in diagonalPrintMap:
for j in diagonalPrintMap[i]:
print j,
print ""

# Driver Program
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 Nikhil Kumar Singh(nickzuck_007)

```

Output :
```Diagonal Traversal of binary tree :
8 10 14
3 6 7 13
1 4
```

# GATE CS Corner    Company Wise Coding Practice

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.
3.5 Average Difficulty : 3.5/5.0
Based on 84 vote(s)

Writing code in comment? Please use ide.geeksforgeeks.org, generate link and share the link here.