Spiral Matrix

                                            
class Solution {
public:
    vector<int> spiralOrder(vector<vector<int>>& matrix) {
        vector<int> result;
        if (matrix.empty()) {
            return result;
        }
        
        int top = 0, bottom = matrix.size() - 1;
        int left = 0, right = matrix[0].size() - 1;
        
        while (top <= bottom && left <= right) {
            for (int i = left; i <= right; i++) {
                result.push_back(matrix[top][i]);
            }
            top++;
            
            for (int i = top; i <= bottom; i++) {
                result.push_back(matrix[i][right]);
            }
            right--;
            
            if (top <= bottom) {
                for (int i = right; i >= left; i--) {
                    result.push_back(matrix[bottom][i]);
                }
                bottom--;
            }
            
            if (left <= right) {
                for (int i = bottom; i >= top; i--) {
                    result.push_back(matrix[i][left]);
                }
                left++;
            }
        }
        
        return result;
    }
};

                                            
class Solution {
    public List<Integer> spiralOrder(int[][] matrix) {
        List<Integer> result = new ArrayList<>();
        if(matrix == null || matrix.length == 0) {
            return result;
        }
        
        int top = 0;
        int bottom = matrix.length - 1;
        int left = 0;
        int right = matrix[0].length - 1;
        
        while(top <= bottom && left <= right) {
            for(int i = left; i <= right; i++) {
                result.add(matrix[top][i]);
            }
            top++;
            
            for(int i = top; i <= bottom; i++) {
                result.add(matrix[i][right]);
            }
            right--;
            
            if(top <= bottom) {
                for(int i = right; i >= left; i--) {
                    result.add(matrix[bottom][i]);
                }
                bottom--;
            }
            
            if(left <= right) {
                for(int i = bottom; i >= top; i--) {
                    result.add(matrix[i][left]);
                }
                left++;
            }
        }
        
        return result;
    }
}

                                            
class Solution(object):
    def spiralOrder(self, matrix):
        """
        :type matrix: List[List[int]]
        :rtype: List[int]
        """
        if not matrix:
            return []
        
        result = []
        top_row = 0
        bottom_row = len(matrix) - 1
        left_col = 0
        right_col = len(matrix[0]) - 1
        
        while top_row <= bottom_row and left_col <= right_col:
            for i in range(left_col, right_col + 1):
                result.append(matrix[top_row][i])
            top_row += 1
            
            for i in range(top_row, bottom_row + 1):
                result.append(matrix[i][right_col])
            right_col -= 1
            
            if top_row <= bottom_row:
                for i in range(right_col, left_col - 1, -1):
                    result.append(matrix[bottom_row][i])
                bottom_row -= 1
            
            if left_col <= right_col:
                for i in range(bottom_row, top_row - 1, -1):
                    result.append(matrix[i][left_col])
                left_col += 1
                
        return result

                                            
/**
 * Note: The returned array must be malloced, assume caller calls free
().
 */
int* spiralOrder(int** matrix, int matrixSize, int* matrixColSize, 
int* returnSize) {
    int rowStart = 0, rowEnd = matrixSize - 1;
    int colStart = 0, colEnd = *matrixColSize - 1;
    int* result = (int*)malloc(matrixSize * (*matrixColSize) * sizeof(int));
    *returnSize = matrixSize * (*matrixColSize);
    int idx = 0;
    
    while (rowStart <= rowEnd && colStart <= colEnd) {
        // Traverse Right
        for (int i = colStart; i <= colEnd; i++) {
            result[idx++] = matrix[rowStart][i];
        }
        rowStart++;

        // Traverse Down
        for (int i = rowStart; i <= rowEnd; i++) {
            result[idx++] = matrix[i][colEnd];
        }
        colEnd--;

        // Traverse Left
        if (rowStart <= rowEnd) {
            for (int i = colEnd; i >= colStart; i--) {
                result[idx++] = matrix[rowEnd][i];
            }
            rowEnd--;
        }

        // Traverse Up
        if (colStart <= colEnd) {
            for (int i = rowEnd; i >= rowStart; i--) {
                result[idx++] = matrix[i][colStart];
            }
            colStart++;
        }
    }
    
    return result;
}

                                            
public class Solution {
    public IList<int> SpiralOrder(int[][] matrix) {
        IList<int> result = new List<int>();
        
        if(matrix == null || matrix.Length == 0) {
            return result;
        }
        
        int top = 0, bottom = matrix.Length - 1;
        int left = 0, right = matrix[0].Length - 1;
        
        while(top <= bottom && left <= right) {
            for(int i = left; i <= right; i++) {
                result.Add(matrix[top][i]);
            }
            top++;
            
            for(int i = top; i <= bottom; i++) {
                result.Add(matrix[i][right]);
            }
            right--;
            
            if(top <= bottom) {
                for(int i = right; i >= left; i--) {
                    result.Add(matrix[bottom][i]);
                }
                bottom--;
            }
            
            if(left <= right) {
                for(int i = bottom; i >= top; i--) {
                    result.Add(matrix[i][left]);
                }
                left++;
            }
        }
        
        return result;
    }
}

                                            
/**
 * @param {number[][]} matrix
 * @return {number[]}
 */
var spiralOrder = function(matrix) {
    const result = [];
    if (matrix === null || matrix.length === 0) {
        return result;
    }
    
    let top = 0;
    let bottom = matrix.length - 1;
    let left = 0;
    let right = matrix[0].length - 1;
    let direction = 0;

    while (top <= bottom && left <= right) {
        if (direction === 0) {
            for (let i = left; i <= right; i++) {
                result.push(matrix[top][i]);
            }
            top++;
        } else if (direction === 1) {
            for (let i = top; i <= bottom; i++) {
                result.push(matrix[i][right]);
            }
            right--;
        } else if (direction === 2) {
            for (let i = right; i >= left; i--) {
                result.push(matrix[bottom][i]);
            }
            bottom--;
        } else if (direction === 3) {
            for (let i = bottom; i >= top; i--) {
                result.push(matrix[i][left]);
            }
            left++;
        }
        direction = (direction + 1) % 4;
    }

    return result;
};

                                            
function spiralOrder(matrix: number[][]): number[] {
    const result: number[] = [];
    let topRow = 0;
    let bottomRow = matrix.length - 1;
    let leftCol = 0;
    let rightCol = matrix[0].length - 1;
    
    while (topRow <= bottomRow && leftCol <= rightCol) {
        for (let i = leftCol; i <= rightCol; i++) {
            result.push(matrix[topRow][i]);
        }
        topRow++;
        
        for (let i = topRow; i <= bottomRow; i++) {
            result.push(matrix[i][rightCol]);
        }
        rightCol--;
        
        if (topRow <= bottomRow) {
            for (let i = rightCol; i >= leftCol; i--) {
                result.push(matrix[bottomRow][i]);
            }
            bottomRow--;
        }
        
        if (leftCol <= rightCol) {
            for (let i = bottomRow; i >= topRow; i--) {
                result.push(matrix[i][leftCol]);
            }
            leftCol++;
        }
    }
    
    return result;
};

                                            
class Solution {
    /**
     * @param Integer[][] $matrix
     * @return Integer[]
     */
    function spiralOrder($matrix) {
        $result = [];
        $top = 0;
        $bottom = count($matrix) - 1;
        $left = 0;
        $right = count($matrix[0]) - 1;
        
        while ($top <= $bottom && $left <= $right) {
            for ($i = $left; $i <= $right; $i++) {
                $result[] = $matrix[$top][$i];
            }
            $top++;

            for ($i = $top; $i <= $bottom; $i++) {
                $result[] = $matrix[$i][$right];
            }
            $right--;

            if ($top <= $bottom) {
                for ($i = $right; $i >= $left; $i--) {
                    $result[] = $matrix[$bottom][$i];
                }
                $bottom--;
            }

            if ($left <= $right) {
                for ($i = $bottom; $i >= $top; $i--) {
                    $result[] = $matrix[$i][$left];
                }
                $left++;
            }
        }
        
        return $result;
    }
}

                                            
class Solution {
    fun spiralOrder(matrix: Array<IntArray>): List<Int> {
        val result = mutableListOf<Int>()
        
        if (matrix.isEmpty()) return result
        
        var top = 0
        var bottom = matrix.size - 1
        var left = 0
        var right = matrix[0].size - 1
        
        while (top <= bottom && left <= right) {
            for (i in left..right) {
                result.add(matrix[top][i])
            }
            top++
            
            for (i in top..bottom) {
                result.add(matrix[i][right])
            }
            right--
            
            if (top <= bottom) {
                for (i in right downTo left) {
                    result.add(matrix[bottom][i])
                }
                bottom--
            }
            
            if (left <= right) {
                for (i in bottom downTo top) {
                    result.add(matrix[i][left])
                }
                left++
            }
        }
        
        return result
    }
}

                                            
class Solution {
  List<int> spiralOrder(List<List<int>> matrix) {
    List<int> result = [];
    if (matrix.isEmpty) return result;

    int rowBegin = 0;
    int rowEnd = matrix.length - 1;
    int colBegin = 0;
    int colEnd = matrix[0].length - 1;

    while (rowBegin <= rowEnd && colBegin <= colEnd) {
      for (int i = colBegin; i <= colEnd; i++) {
        result.add(matrix[rowBegin][i]);
      }
      rowBegin++;

      for (int i = rowBegin; i <= rowEnd; i++) {
        result.add(matrix[i][colEnd]);
      }
      colEnd--;

      if (rowBegin <= rowEnd) {
        for (int i = colEnd; i >= colBegin; i--) {
          result.add(matrix[rowEnd][i]);
        }
      }
      rowEnd--;

      if (colBegin <= colEnd) {
        for (int i = rowEnd; i >= rowBegin; i--) {
          result.add(matrix[i][colBegin]);
        }
      }
      colBegin++;
    }

    return result;
  }
}

                                            
func spiralOrder(matrix [][]int) []int {
    if len(matrix) == 0 {
        return []int{}
    }
    
    rows, cols := len(matrix), len(matrix[0])
    result := make([]int, rows*cols)
    
    top, bottom, left, right := 0, rows-1, 0, cols-1
    idx := 0
    
    for {
        // Traverse top row
        for i := left; i <= right; i++ {
            result[idx] = matrix[top][i]
            idx++
        }
        top++
        if top > bottom || left > right {
            break
        }
        
        // Traverse right column
        for i := top; i <= bottom; i++ {
            result[idx] = matrix[i][right]
            idx++
        }
        right--
        if top > bottom || left > right {
            break
        }
        
        // Traverse bottom row
        for i := right; i >= left; i-- {
            result[idx] = matrix[bottom][i]
            idx++
        }
        bottom--
        if top > bottom || left > right {
            break
        }
        
        // Traverse left column
        for i := bottom; i >= top; i-- {
            result[idx] = matrix[i][left]
            idx++
        }
        left++
        if top > bottom || left > right {
            break
        }
    }
    
    return result
}

                                            
# @param {Integer[][]} matrix
# @return {Integer[]}
def spiral_order(matrix)
    result = []
    while matrix.any?
        result += matrix.shift
        matrix = matrix.transpose.reverse
    end
    result
end

                                            
object Solution {
    def spiralOrder(matrix: Array[Array[Int]]): List[Int] = {
        if (matrix.isEmpty) return List()

        var top = 0
        var bottom = matrix.length - 1
        var left = 0
        var right = matrix(0).length - 1

        var direction = 0 // 0 -> right, 1 -> down, 2 -> left, 3 -> up
        var result = List[Int]()

        while (top <= bottom && left <= right) {
            if (direction == 0) {
                for (i <- left to right) {
                    result = result :+ matrix(top)(i)
                }
                top += 1
            } else if (direction == 1) {
                for (i <- top to bottom) {
                    result = result :+ matrix(i)(right)
                }
                right -= 1
            } else if (direction == 2) {
                for (i <- right to left by -1) {
                    result = result :+ matrix(bottom)(i)
                }
                bottom -= 1
            } else if (direction == 3) {
                for (i <- bottom to top by -1) {
                    result = result :+ matrix(i)(left)
                }
                left += 1
            }
            direction = (direction + 1) % 4
        }

        result
    }
}

                                            
impl Solution {
    pub fn spiral_order(matrix: Vec<Vec<i32>>) -> Vec<i32> {
        let (mut top, mut bottom, mut left, mut right) = (0, matrix.len() as i32 - 1, 0, matrix[0].len() as i32 - 1);
        let mut result = Vec::new();

        while top <= bottom && left <= right {
            for i in left..=right {
                result.push(matrix[top as usize][i as usize]);
            }
            top += 1;

            for i in top..=bottom {
                result.push(matrix[i as usize][right as usize]);
            }
            right -= 1;

            if top <= bottom {
                for i in (left..=right).rev() {
                    result.push(matrix[bottom as usize][i as usize]);
                }
                bottom -= 1;
            }

            if left <= right {
                for i in (top..=bottom).rev() {
                    result.push(matrix[i as usize][left as usize]);
                }
                left += 1;
            }
        }

        result
    }
}

To solve this coding challenge, we need to traverse through the elements of a matrix in a spiral order. A spiral order means starting from the top-left corner and moving right across the top row, then down the rightmost column, then left across the bottom row, and finally up the leftmost column. This pattern repeats, moving inward layer by layer until all elements have been visited.

Explanation

Given an

m x n

matrix, our objective is to read its elements in a spiral order. This involves iterating over the matrix and adjusting our traversal boundaries as we move layer by layer toward the center. We will use four boundary variables —

top_row

bottom_row

left_col

, and

right_col

— which will define the current periphery that we are traversing.

Steps to Solve:

Initialize Boundaries:

top_row

to 0 (initially at the top row of the matrix).
bottom_row

to m-1 (initially at the bottom row of the matrix).
left_col

to 0 (initially at the leftmost column of the matrix).
right_col

to n-1 (initially at the rightmost column of the matrix).

Iterative Traversal:

Move right across the
top_row

and increment
top_row

.
Move down the
right_col

and decrement
right_col

.
Check if
top_row

<=
bottom_row

before traversing the
bottom_row

from right to left, then decrement
bottom_row

.
Check if
left_col

<=
right_col

before traversing the
left_col

from bottom to top, then increment
left_col

.

Check for Completion:

The loop continues until
top_row

exceeds
bottom_row

or
left_col

exceeds
right_col

.

Detailed Steps in Pseudocode:

                                            
# Initialize function with matrix input
FUNCTION spiralOrder(matrix):
    # Handle edge case for an empty matrix
    IF matrix IS empty THEN
        RETURN empty list
 
    # Initialize the result list to store spiral order
    result = []
    
    # Initialize boundaries
    top_row = 0
    bottom_row = number of rows in matrix - 1
    left_col = 0
    right_col = number of columns in matrix - 1
    
    # Continue traversing while the boundaries are valid
    WHILE top_row <= bottom_row AND left_col <= right_col:
        # Traverse from the left to the right along the top row
        FOR i FROM left_col TO right_col:
            APPEND matrix[top_row][i] TO result
        # Move the top boundary down
        INCREMENT top_row
        
        # Traverse from the top to the bottom along the right column
        FOR i FROM top_row TO bottom_row:
            APPEND matrix[i][right_col] TO result
        # Move the right boundary left
        DECREMENT right_col
        
        # Check if there are remaining rows to traverse
        IF top_row <= bottom_row THEN
            # Traverse from the right to the left along the bottom row
            FOR i FROM right_col TO left_col STEP -1:
                APPEND matrix[bottom_row][i] TO result
            # Move the bottom boundary up
            DECREMENT bottom_row
        
        # Check if there are remaining columns to traverse
        IF left_col <= right_col THEN
            # Traverse from the bottom to the top along the left column
            FOR i FROM bottom_row TO top_row STEP -1:
                APPEND matrix[i][left_col] TO result
            # Move the left boundary right
            INCREMENT left_col
    
    # Return the result list containing all elements in spiral order
    RETURN result

This pseudocode carefully elaborates every required step to traverse the given matrix in a spiral order and ensures the boundaries are correctly adjusted in each iteration. The conditions within the loops ensure that the algorithm terminates correctly once it has traversed all the levels of the matrix from the outermost to the innermost one.