How I Solved Spiral Matrix on LeetCode Using Layers

Some coding questions look simple at first.

Then you start solving them and realize the real challenge is not the idea - it is handling all the small cases correctly.

That happened to me while solving the Spiral Matrix problem on LeetCode.

The problem asks us to return all elements of a matrix in spiral order.

At first, I thought about using directions like right, down, left, up.

But then I found a simpler way to think about it.

---

My Main Idea: Solve It Layer by Layer

I used a variable called k.

k = 0

Where:

• k = 0 means the outer layer
• k = 1 means the next inner layer
• k = 2 means the next one inside

For every layer, I created boundaries:

• top = k
• bottom = rows - 1 - k
• left = k
• right = cols - 1 - k

As k increases, the boundaries move inward.

This made the problem much easier to understand.

---

Four Passes for Every Layer

For each layer, I moved in four steps:

pass1
Left to right on the top row

pass2
Top to bottom on the right column

pass3
Right to left on the bottom row

pass4
Bottom to top on the left column

Then I increased k and repeated the same process.

---

Problems I Faced

The logic was correct, but I still had bugs like:

• duplicate elements
• wrong loop conditions
• wrong index positions
• infinite loop
• failing small test cases

The biggest lesson was this:

Even if the main idea is right, small edge cases can break everything.

---

Important Edge Cases

Single Row Matrix

[1,2,3]

If I ran all four passes, some values repeated.

So I had to run pass3 only when:

top < bottom

Single Column Matrix

[1]
[2]
[3]

I also had to run pass4 only when:

left < right

---

Final Java Code

class Solution {
    public List<Integer> spiralOrder(int[][] matrix) {

        int rows = matrix.length;
        int cols = matrix[0].length;
        List<Integer> output = new ArrayList<>();
        int k = 0;

        while (k <= (rows - 1) - k && k <= (cols - 1) - k) {

            int top = k;
            int bottom = (rows - 1) - k;
            int left = k;
            int right = (cols - 1) - k;

            //pass1
            for (int j = left; j <= right; j++) {
                output.add(matrix[top][j]);
            }

            //pass2
            for (int i = top + 1; i <= bottom; i++) {
                output.add(matrix[i][right]);
            }

            //pass3
            if (top < bottom) {
                for (int j = right - 1; j >= left; j--) {
                    output.add(matrix[bottom][j]);
                }
            }

            //pass4
            if (left < right) {
                for (int i = bottom - 1; i >= top + 1; i--) {
                    output.add(matrix[i][left]);
                }
            }

            k++;
        }

        return output;
    }
}

Thank you for reading !!!

Comments

[Nishkarsh Pandey]

Really well explained! The layer-by-layer approach makes the problem feel much more intuitive, especially compared to juggling directions. Also liked how you highlighted the edge cases — that’s where most people get stuck

[Bhuvi D]

Thank you 😊