# Spiral Matrix — Problem solution

Day 8 — 100DaysCodingChallenge

**Problem:**

Given an `m x n`

`matrix`

, return *all elements of the* `matrix`

*in spiral order*.

`m == matrix.length`

n == matrix[i].length

1 <= m, n <= 10

-100 <= matrix[i][j] <= 100

**Solution:**

Defining all the variables required for the solution. The variable ** direction **defines the direction in which the loop will continue and the variable

**could be any invalid integer number (<-100 or >100).**

*doom***Directions:** 0 - right, 1- down, 2-left, and 3-up.

`class Solution {`

public List<Integer> spiralOrder(int[][] m) {

int direction = 0, i = 0, j = 0;

int M = m.length, N = m[0].length, doom = 1000;

List<Integer> out = new ArrayList<>();

The loop will continue for each and every item in the matrix as long as the value of index** i** and

**are valid and**

*j***m[i][j]**is not

**.**

*doom*`while (i >= 0 && j >= 0 && i < M && j < N && m[i][j] != doom) {`

The initial ** direction **will be

**as it was set to 0 while initialized and it’ll be updated to continue as a spiral (right > down > left > up).**

*right*Based on the current direction, the inner while loop will read all the following items from the matrix in the same row or the column as long as there are items to be read and the item isn’t ** doom**.

After each inner while loop, the value of ** i** or

**will be one block ahead (based on the direction). Bring that block down, increment one block in the next direction and change the direction to the next direction.**

*j*` switch (direction) {`

case 0:

while (j < N && m[i][j] != doom) {

out.add(m[i][j]);

m[i][j] = doom;

j++;

}

j--; i++; direction = 1;

break;

case 1:

while (i < M && m[i][j] != doom) {

out.add(m[i][j]);

m[i][j] = doom;

i++;

}

i--; j--; direction = 2;

break;

case 2:

while (j >= 0 && m[i][j] != doom) {

out.add(m[i][j]);

m[i][j] = doom;

j--;

}

j++; i--; direction = 3;

break;

case 3:

default:

while (i >= 0 && m[i][j] != doom) {

out.add(m[i][j]);

m[i][j] = doom;

i--;

}

i++; j++; direction = 0;

break;

}

}

return out;

}

}

# Complexity:

Time Complexity: O(m*n)

Space Complexity: O(m*n)