LeetCode 54. 螺旋矩阵

https://leetcode-cn.com/problems/spiral-matrix/

这个题应该也是剑指offer上的原题吧，难点觉得就是在怎么解决边界值的问题，就是你每次在寻找元素的时候应该在哪里开始、在哪里结束。这个题我做了三次，感觉都不是特别的熟练，在找边界的时候还是花了点时间。

第一次做：

class Solution {
    public List<Integer> spiralOrder(int[][] matrix) {
        if(matrix == null || matrix.length == 0 || matrix[0].length == 0){
            return new ArrayList<Integer>();
        }
        ArrayList<Integer> list = new ArrayList<>();
        int amount = matrix.length * matrix[0].length;
        int lastMod = 0;
        while(list.size()<amount){
            int i = lastMod;
            int j = lastMod;
            for(i = lastMod;i<matrix[0].length-lastMod;i++){
                if(!list.contains(matrix[lastMod][i])){
                    list.add(matrix[lastMod][i]);
                }else {
                    break;
                }
            }
            i--;
            for (j = lastMod+1;j<matrix.length-lastMod;j++){
                if(!list.contains(matrix[j][i])){
                    list.add(matrix[j][i]);
                }else {
                    break;
                }

            }
            j--;
            for (i = matrix[0].length-lastMod-2;i>=0;i--){
                if(!list.contains(matrix[j][i])){
                    list.add(matrix[j][i]);
                }else {
                    break;
                }
            }
            i++;
            for (j = matrix.length-lastMod-2;j>=0;j--){
                if(!list.contains(matrix[j][i])){
                    list.add(matrix[j][i]);
                }else {
                    break;
                }
            }
            lastMod = j+1;
        }
        return list;
    }
}

这个最大的问题是用了contains来判断list中是否存在该元素，如果题目的数据是可以重复的话，我这里已经GG了。

第二次：

class Solution {
    public List<Integer> spiralOrder(int[][] matrix) {
        List<Integer> list = new ArrayList<>();
        if(matrix.length == 0){
            return list;
        }
        int sum = matrix.length * matrix[0].length;
        int level = 0;
        while(list.size() < sum){
            for(int i = level; i < matrix[level].length - level; i++){
                list.add(matrix[level][i]);
            }
            if((list.size() >= sum)){
                break;
            }
            for(int j = level + 1; j < matrix.length - level - 1; j++){
                list.add(matrix[j][matrix[j].length - level - 1]);
            }
            if((list.size() >= sum)){
                break;
            }
            for(int i = matrix[level].length - level- 1; i > level; i--){
                list.add(matrix[matrix.length-level - 1][i]);
            }
            if((list.size() >= sum)){
                break;
            }
            for(int j = matrix.length - level - 1; j > level; j--){
                list.add(matrix[j][level]);
                if((list.size() >= sum)){
                    break;
                }
            }
            level++;
        }
        return list;
    }
}

第二次做的时候这个边界问题真的是烦人，搞得我只好多用几个判断来将那些多次重复输入的元素剔除掉，真的挺头疼的。

后来看了下评论区，发现有更好更容易理解的方法，边界值也比较好找，就按照他的思想做了一次。

class Solution {
    public List<Integer> spiralOrder(int[][] matrix) {
        List<Integer> list = new ArrayList<>();
        if(matrix.length == 0){
            return list;
        }
        int sum = matrix.length * matrix[0].length;
        int l = 0;
        int r = matrix[0].length - 1;
        int u = 0;
        int d = matrix.length-1;
        while(l <= r && u <= d){
            for(int i = l; i <= r; i++){
                list.add(matrix[u][i]);
            }
            u++;
            for(int i = u; i <= d; i++){
                list.add(matrix[i][r]);
            }
            r--;
            for(int i = r; i >= l && u <= d; i--){
                list.add(matrix[d][i]);
            }
            d--;
            for(int i = d; i>= u && l <= r; i--){
                list.add(matrix[i][l]);
            }
            l++;
        }
        return list;
    }
}

这个主要就是靠l,r,u,d来控制边界，四个变量分别代表左边边界，右边边界，上边边界和下边边界。

另外就是判断的时候要注意最后两个要判断上边界是否小于等于下边界和左边界是否小于等于右边界，如果不进行这个判断同样也是会出现重复的元素的。

希望这三次做题能给自己再提个醒吧，刷完题一定要好好回顾下，记忆力强一点！