304 North Cardinal St.
Dorchester Center, MA 02124

# Diagonal Traverse LeetCode Solution

## Problem – Diagonal Traverse

Given an `m x n` matrix `mat`, return an array of all the elements of the array in a diagonal order.

Example 1:

``````Input: mat = [[1,2,3],[4,5,6],[7,8,9]]
Output: [1,2,4,7,5,3,6,8,9]``````

Example 2:

``````Input: mat = [[1,2],[3,4]]
Output: [1,2,3,4]``````

Constraints:

• `m == mat.length`
• `n == mat[i].length`
• `1 <= m, n <= 104`
• `1 <= m * n <= 104`
• `-105 <= mat[i][j] <= 105`

### Diagonal Traverse LeetCode Solution in Java

``````    public int[] findDiagonalOrder(int[][] matrix) {
if (matrix.length == 0) return new int[0];
int r = 0, c = 0, m = matrix.length, n = matrix[0].length, arr[] = new int[m * n];
for (int i = 0; i < arr.length; i++) {
arr[i] = matrix[r][c];
if ((r + c) % 2 == 0) { // moving up
if      (c == n - 1) { r++; }
else if (r == 0)     { c++; }
else            { r--; c++; }
} else {                // moving down
if      (r == m - 1) { c++; }
else if (c == 0)     { r++; }
else            { r++; c--; }
}
}
return arr;
}
``````

### Diagonal Traverse LeetCode Solution in C++

``````vector<int> findDiagonalOrder(vector<vector<int>>& matrix) {
if(matrix.empty()) return {};

const int N = matrix.size();
const int M = matrix[0].size();

vector<int> res;
for(int s = 0; s <= N + M - 2; ++s)
{
// for all i + j = s
for(int x = 0; x <= s; ++x)
{
int i = x;
int j = s - i;
if(s % 2 == 0) swap(i, j);

if(i >= N || j >= M) continue;

res.push_back(matrix[i][j]);
}
}

return res;
}
``````

### Diagonal Traverse LeetCode Solution in Python

``````class Solution(object):
def findDiagonalOrder(self, matrix):
"""
:type matrix: List[List[int]]
:rtype: List[int]
"""
result = [ ]
dd = collections.defaultdict(list)
if not matrix: return result
# Step 1: Numbers are grouped by the diagonals.
# Numbers in same diagonal have same value of row+col
for i in range(0, len(matrix)):
for j in range(0, len(matrix[0])):
dd[i+j+1].append(matrix[i][j]) # starting indices from 1, hence i+j+1.
# Step 2: Place diagonals in the result list.
# But remember to reverse numbers in odd diagonals.
for k in sorted(dd.keys()):
if k%2==1: dd[k].reverse()
result += dd[k]
return result
``````
##### Diagonal Traverse LeetCode Solution Review:

In our experience, we suggest you solve this Diagonal Traverse LeetCode Solution and gain some new skills from Professionals completely free and we assure you will be worth it.

If you are stuck anywhere between any coding problem, just visit Queslers to get the Diagonal Traverse LeetCode Solution

Find on LeetCode

##### Conclusion:

I hope this Diagonal Traverse LeetCode Solution would be useful for you to learn something new from this problem. If it helped you then don’t forget to bookmark our site for more Coding Solutions.

This Problem is intended for audiences of all experiences who are interested in learning about Data Science in a business context; there are no prerequisites.

Keep Learning!

More Coding Solutions >>

LeetCode Solutions

Hacker Rank Solutions

CodeChef Solutions