5.2

移除元素

方法1：

暴力循环

循环一遍所有的数；
如果碰到了等于目标值的时候，那么就将所有值都向前移动一位，直到所有数据结尾
每次移动的时候，将循环的次数进行一次减少，即i--；同时，所有里面的数也需要减减

class Solution {
   public int removeElement(int[] nums, int val) {
       int length  =nums.length;
       for (int i = 0;i<length ;i++){
           if(nums[i] ==val){
               for(int j =i+1;j<length;j++){
                   nums[j-1] =nums[j];
               }
                i--;
                length--; 
           }
       }return length;
   }
}

方法2：

双指针法：

采用快慢指针；
将快指针从头到尾遍历所有数；
如果快的指针的值不等于想要消除的数；那么就快指针的值赋值给慢指针；
最后返回慢指针的总个数

class Solution {
   public int removeElement(int[] nums, int val) {
       int slow=0 ;
       int fast;
       for(fast=0;fast<nums.length;fast++){
           if(nums[fast]!=val){
               nums[slow] =nums[fast];
               slow++;
           }

       }return slow;

   }
}

有序数组的平方

双指针法：

因为原本数组是有序的，只不过是因为存在平方后会变成新的最大值，所以可以采取用头和尾指针；
头指针指向0，从此开始往后遍历，尾指针指向nums.length
创建一个新的数组用于存放结果
定义一个数组存放的指针k，为了知道能放的数；从nums.length-1开始放，然后每次减减，保证两次数量是一样的；

class Solution {
   public int[] sortedSquares(int[] nums) {
       int left=0;
       int right =nums.length-1;
       int [] num  = new int [nums.length];
       int k = nums.length -1;//关于这里为什么k不能从0开始，因为呢
                              //这里原本就是有序数组，从小到大排序
       while(left <=right){
           if(nums[left]*nums[left]>=nums[right]*nums[right]){
               num[k] = nums[left]*nums[left];left++;
           }else{
               num[k]=nums[right]*nums[right];right--;
           }k--;
       }return num;
   }
}

长度最小的子数组

暴力法：

关于什么时候可以直接暴力：如果是可以将后面一个数覆盖原来的数的话，那么就是可以直接暴力的；还是没有明确的认识怎么暴力解题

两次循环。定义一个sum值，记录总值；
在第二次循环中都是从i下标开始，看每一次从不同的下标开始，是不是存在更小的答案，如果存在是更小的那么就直接将其覆盖

class Solution {
   public int minSubArrayLen(int target, int[] nums) {
       int res  =Integer.MAX_VALUE;
       int tem = 0;
       int size =nums.length;
       int sum =0;
       for(int i =0;i<size;i++){
           sum = 0;
           for(int j =i ;j<size;j++){
               sum += nums[j];
               if(sum>=target){
                   tem = j-i+1;
                   res = res>tem?tem:res;
                   break;
               }
           }
       }return res = res ==Integer.MAX_VALUE?0:res;
   }
}

双指针法（这里也称滑动窗口法）

创建两个指针；都是从头开始；第一个指针先自己走，在走的时候进行sum +=nums[指针]；当sum的值>=target的时候；
这个时候需要移动另一个指针，先找到当前的长度。用第一个指针的位置-第二个指针的位置+1；就是得到的res的值；比较res与之前的值。然后返回出res
将原来的sum减少，从第二个指针的值开始减。即sum -=nums[left];
这个结束的条件就是sum比target大的时候
注释：关于覆盖值的问题，和与前一个值比较的问题，可以采用定义一个全局变量；然后采用Math.min/max(现在的值，定义的全局变量的值);

class Solution {
   public int minSubArrayLen(int target, int[] nums) {
       int left= 0;
       int sum =0;
       int tem =0;
       int res =Integer.MAX_VALUE;
       for (int i =0;i <nums.length;i++){
           sum += nums[i];
           while(sum>=target){
               tem = i -left+1;
               res =Math.min(tem,res);
               sum -=nums[left++];
           }
       }return res = res==Integer.MAX_VALUE?0:res;
   }
}