day02-leetcode（数组）

283：移动零

题目描述：给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序。

请注意 ，必须在不复制数组的情况下原地对数组进行操作。

思路：使用快慢指针，将非零元素往前移动，数组中后面的其余元素则为0。

class Solution {
    public void moveZeroes(int[] nums) {
        int len=nums.length;
        int slow=0,fast=0;
        for(fast=0;fast<len;fast++){
            if(nums[fast]!=0){
                nums[slow]=nums[fast];
                slow++;
            }
        }
        //第slow个元素后的值都为0
        for(;slow<len;slow++){
            nums[slow]=0;
        }
    }
}

977：有序数组的平方

题目描述：给你一个按 非递减顺序 排序的整数数组 nums，返回 每个数字的平方 组成的新数组，要求也按 非递减顺序 排序。

解法一：暴力破解

现将数组小于零的值转为正数，再通过冒泡排序从小到大进行排序，再将数组中的值平方即可。

class Solution {
    public int[] sortedSquares(int[] nums) {
       //暴力解法：将数组中的数取绝对值，再排序
       int len=nums.length;
       //取绝对值
       for(int i=0;i<len;i++){
           if(nums[i]<0) nums[i]=0-nums[i];
       }
       //冒泡排序
       for(int i=0;i<len;i++){
           for(int j=i+1;j<len;j++){
               if(nums[i]>nums[j]){
                   int temp=nums[i];
                   nums[i]=nums[j];
                   nums[j]=temp;
               }
           }
       }
       //平方
       for(int i=0;i<len;i++){
           nums[i]=nums[i]*nums[i];
       }
       return nums;
}
}

解法二：快慢指针

因为该数组为非递减顺序，因此数组中每个数字的平方组成的新数组中的最大值，肯定在原数组的两端。

因此可以定义一个新数组res,和原数组大小一样，用于从将最大的数组依次从数组后面的位置向前保存。

class Solution {
    public int[] sortedSquares(int[] nums) {
    int len=nums.length;
    int first=0,end=len-1;
    int[] res=new int[len];
    int index=len-1;
    while(index>=0){
        if(nums[first]*nums[first]>nums[end]*nums[end]){
            res[index]=nums[first]*nums[first];
            first++;
        }else{
            res[index]=nums[end]*nums[end];
            end--;
        }
        index--;
    }
    return res;
}
}

209：长度最小的子数组

题目描述：

给定一个含有 n 个正整数的数组和一个正整数 target 。

找出该数组中满足其总和大于等于 target 的长度最小的 连续子数组 [numsl, numsl+1, ..., numsr-1, numsr] ，并返回其长度。如果不存在符合条件的子数组，返回 0 。

解法一：暴力破解：超出时间限制

class Solution {
    public int minSubArrayLen(int target, int[] nums) {
        int len=nums.length;
        int res=len+1;
        for(int i=0;i<len;i++){
            int sum=nums[i];
            if(sum>=target) return 1;
            for(int j=i+1;j<len;j++){
                sum+=nums[j];
                if(sum>=target&&res>(j-i+1)){
                    res=j-i+1;
                }
            }
        }
        if(res>len) res=0;
        return res;
    }
}

 解法二：滑动窗口

滑动窗口：不断调节子序列的起始位置和终止位置

窗口内：满足窗口内连续数组和>=target

窗口的起始位置移动：如果当前窗口的值>=target，窗口就要向前移动（窗口缩小）

窗口的结束位置移动：遍历数组

class Solution {
    public int minSubArrayLen(int target, int[] nums) {
        int len=nums.length;
        int res=Integer.MAX_VALUE;
        int left=0,right=0,sum=0; //滑动窗口的起始位置、终止位置、子序列和
        for(right=0;right<len;right++){
            sum+=nums[right];
            //起始位置不断缩小，判断子序列是否符合条件
            while(sum>=target){    
                int sublen=right-left+1;  //滑动窗口的大小
                res=Math.min(res,sublen); //取最小值
                sum-=nums[left];         //起始位置前进，减去前面已经加上的数组值
                left++;                //变更起始位置
            }
        }
     // 如果result没有被赋值的话，就返回0，说明没有符合条件的子序列
        return res==Integer.MAX_VALUE?0:res;
    }
}