动态数组编程题

1.力扣54 螺旋矩阵

通过找规律我们可以发现，顺时针螺旋出来的顺序就是要从数字“1”开始走，向右走到“3”，然后向下走到“9”，再向左走到“7”，再向上走到“4”，再向右走到“5”。这样走一圈，就完成了顺时针螺旋顺序。
我们再找规律，向右是横坐标不变，纵坐标+1。向下是纵坐标不变，横坐标+1。向左是横坐标不变 ，纵坐标-1。向上是纵坐标不变，横坐标-1。这样我们就分析出了所有变化坐标的规律。
我们可以用数字来表示这些规律。我们把最开始的位置设置为0，0 ；横坐标：int【】 delx={0,1,0，-1} 纵坐标：int 【】dely={1,0，-1,0}
定义一个变量来表示方向。然后把方向这两个坐标里，看是哪种情况。

代码如下：

class Solution {
    public List<Integer> spiralOrder(int[][] matrix) {
        ArrayList<Integer> list= new ArrayList<Integer>();
        if(matrix==null||matrix.length==0||matrix[0].length==0){
            return list;
        }
        int x=0;
        int y=0;
        int r=matrix.length;
        int c=matrix[0].length;
        boolean[][] visited=new boolean[r][c];	//判断是否走过
        int[] delx={0,1,0,-1};
        int[] dely={1,0,-1,0};
        int dir=0;		//方向
        for(int i =0;i<r*c;i++){
            list.add(matrix[x][y]);
            visited[x][y]=true;		//走过的位置
            int nx=x+delx[dir];
            int ny=y+dely[dir];
            if(nx>=0&&nx<r&&ny>=0&&ny<c&&!visited[nx][ny]){	//同一方向
                x=nx;
                y=ny;
            }else{	//换方向
                dir=(dir+1)%4;//从0开始，代表的是数组的四种情况，对4取余判断方向
                x+=delx[dir];
                y+=dely[dir];
            }
        }
        return list;
    }
}

2.力扣209 长度最小的子数组

题目意思很明显，就是让我们找到数组中相加和为目标数的连续数字，且长度必须为最小的。
这里我们的思路应该采用滑窗机制，给数组设置两个指针，定义一个长度。
如图：

先移动下面的j指针，然后加上j指针对应的数值，跟目标数比较，小于就j++，大于就i–。
让长度等于最小的子数组。最后返回子数组长度即可。

代码如下:

 public int minSubArrayLen(int s, int[] nums) {
        if(nums==null||nums.length==0){
            return 0;
        }
        int i=0;
        int len=0;
        int sum=0;
        for(int j=0;j<nums.length;j++){
            sum+=nums[j];	//先移动j指针，然后加上j指针对应的数值
            while(sum>=s){
                len=len==0?j-i+1:Math.min(len,j-i+1);//先判断是否是0，是0为j-i+1，不是则取最短的len：j-i+1.
                sum-=nums[i++];	//i指针前移，减去前面的数值
            }
        }
        return len;	//返回最短连续子数组的长度
    }

3.力扣240 搜索二维矩阵Ⅱ

我们可以很明显的发现这个二维矩阵数字的排列是有规律的。从左到右是升序，从上到下是升序。那我们搜索这个目标值就可以利用这个规律。
如图：

固定寻找的第一个位置，就是数字“18”所在的位置，然后比它大就向右边走，比它小就向上走。这样时间复杂度就是O（m+n）。

代码如下：

public boolean searchMatrix(int[][] matrix, int target) {
        if(matrix==null||matrix.length==0||matrix[0].length==0){
            return false;
        }
        int row=matrix.length;	//定义行
        int col=matrix[0].length;	//定义列
        int x=row-1;		//起始行的位置
        int y=0;			//起始列的位置
        while(true){
            if(x<0||y>=col){		//行或者列超出范围
                return false;
            }
            if(matrix[x][y]<target){	//当前值小于目标值，朝右走 列加1
                y++;
            }else if(matrix[x][y]>target){	//当前值大于目标值 朝左走 行减1
                x--;
            }else{
                return true;	//正好就返回true 表示找到
            }
        }
    }