LeetCode实战：螺旋矩阵

题目英文

Given a matrix of m x n elements (m rows, n columns), return all elements of the matrix in spiral order.

Example 1:

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

Example 2:

Input:
[
  [1, 2, 3, 4],
  [5, 6, 7, 8],
  [9,10,11,12]
]
Output: [1,2,3,4,8,12,11,10,9,5,6,7]

---

题目中文

给定一个包含 m x n 个元素的矩阵（m 行, n 列），请按照顺时针螺旋顺序，返回矩阵中的所有元素。

示例 1:

输入:
[
 [ 1, 2, 3 ],
 [ 4, 5, 6 ],
 [ 7, 8, 9 ]
]
输出: [1,2,3,6,9,8,7,4,5]

示例 2:

输入:
[
  [1, 2, 3, 4],
  [5, 6, 7, 8],
  [9,10,11,12]
]
输出: [1,2,3,4,8,12,11,10,9,5,6,7]

示例 3:

输入:
[
  [1]
]
输出: [1]

示例 4:

输入:
[
  [2, 3, 4],
  [5, 6, 7],
  [8, 9, 10],
  [11, 12, 13]
]
输出: [2,3,4,7,10,13,12,11,8,5,6,9]

---

算法实现

public class Solution
{
    public IList<int> SpiralOrder(int[][] matrix)
    {
        IList<int> result = new List<int>();
        if (matrix == null || matrix.Length == 0)
            return result;

        int start = 0;
        int end1 = matrix[start].Length - 1 - start;
        int end2 = matrix.Length - 1 - start;

        // 只有横着的情况
        if (start == end2)
        {
            LeftToRight(start, end1, start, matrix, result);
            return result;
        }
        //只有竖着的情况
        if (start == end1)
        {
            TopToBottom(start, end2, start, matrix, result);
            return result;
        }

        while (start < end1 && start < end2)
        {
            LeftToRight(start, end1, start, matrix, result);
            TopToBottom(start + 1, end2, end1, matrix, result);
            RightToLeft(end1 - 1, start, end2, matrix, result);
            BottomToTop(end2 - 1, start + 1, start, matrix, result);
            start++;
            end1 = matrix[start].Length - 1 - start;
            end2 = matrix.Length - 1 - start;
        }
        // 只剩下横着的情况
        if (start == end2)
        {
            LeftToRight(start, end1, start, matrix, result);
        }
        else if (start == end1)
        {
            //只剩下竖着的情况
            TopToBottom(start, end2, start, matrix, result);
        }
        return result;
    }

    private void LeftToRight(int start, int end, int rowIndex, int[][] matrix, IList<int> lst)
    {
        for (int i = start; i <= end; i++)
        {
            lst.Add(matrix[rowIndex][i]);
        }
    }

    private void TopToBottom(int start, int end, int colIndex, int[][] matrix, IList<int> lst)
    {
        for (int i = start; i <= end; i++)
        {
            lst.Add(matrix[i][colIndex]);
        }
    }

    private void RightToLeft(int start, int end, int rowIndex, int[][] matrix, IList<int> lst)
    {
        for (int i = start; i >= end; i--)
        {
            lst.Add(matrix[rowIndex][i]);
        }
    }

    private void BottomToTop(int start, int end, int colIndex, int[][] matrix, IList<int> lst)
    {
        for (int i = start; i >= end; i--)
        {
            lst.Add(matrix[i][colIndex]);
        }
    }
}

---

实验结果

• 状态：通过
• 22 / 22 个通过测试用例
• 执行用时: 348 ms, 在所有 C# 提交中击败了 85.53% 的用户
• 内存消耗: 28.9 MB, 在所有 C# 提交中击败了 5.26% 的用户

---

相关图文

1. “数组”类算法

• LeetCode实战：三数之和
• LeetCode实战：最接近的三数之和
• LeetCode实战：求众数
• LeetCode实战：缺失的第一个正数
• LeetCode实战：快乐数
• LeetCode实战：寻找两个有序数组的中位数
• LeetCode实战：盛最多水的容器
• LeetCode实战：删除排序数组中的重复项
• LeetCode实战：搜索旋转排序数组

2. “链表”类算法

• LeetCode实战：两数相加
• LeetCode实战：删除链表的倒数第N个节点
• LeetCode实战：合并两个有序链表
• LeetCode实战：合并K个排序链表
• LeetCode实战：两两交换链表中的节点
• LeetCode实战：旋转链表
• LeetCode实战：环形链表

3. “栈”类算法

• LeetCode实战：有效的括号
• LeetCode实战：最长有效括号
• LeetCode实战：逆波兰表达式求值

4. “队列”类算法

• LeetCode实战：设计循环双端队列
• LeetCode实战：滑动窗口最大值
• LeetCode实战：整数反转
• LeetCode实战：字符串转换整数 (atoi)

5. “递归”类算法

• LeetCode实战：爬楼梯

6. “字符串”类算法

• LeetCode实战：反转字符串
• LeetCode实战：翻转字符串里的单词
• LeetCode实战：最长公共前缀
• LeetCode实战：字符串相加
• LeetCode实战：字符串相乘

7. “树”类算法

• LeetCode实战：相同的树
• LeetCode实战：对称二叉树
• LeetCode实战：二叉树的最大深度
• LeetCode实战：将有序数组转换为二叉搜索树

8. “哈希”类算法

• LeetCode实战：两数之和

9. “搜索”类算法

• LeetCode实战：搜索二维矩阵

10. “动态规划”类算法

• LeetCode实战：最长回文子串
• LeetCode实战：最大子序和

11. “回溯”类算法

• LeetCode实战：全排列

11. “数值分析”类算法

• LeetCode实战：回文数
• LeetCode实战：x 的平方根