【算法第一天7.13】二分查找，删除重复数据重复元素，有序数组的平方，长度最小的子数组

链接：牛客160-二分查找

思路：先看目标元素比中间值大还是小，若大，则目标在右边，需要将左边界替换为mid+1，因为mid是不断更新的，所以需要在while循环的里面
注意：边界必须为+1，或者-1，因为判断时为>,<

import java.util.*;
public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     *
     * @param nums int整型一维数组
     * @param target int整型
     * @return int整型
     */
    public int search (int[] nums, int target) {
        int left = 0;
        int right = nums.length - 1;
        while (left <= right) {
            int mid = (left + right) / 2;
            if (target < nums[mid]) {
                right = mid-1;
            } else if (target > nums[mid]) {
                left = mid+1;
            } else {
                return mid;
            }
        }
        return -1;
    }
}

链接力扣27-删除数组重复元素
思路：快慢指针，题中不需要把重复元素删除
1、只用一个索引来保留不重复元素的长度
2、用fast来遍历所有元素

一旦有nums[fast]和val不同,则让slow++

class Solution {
    public int removeElement(int[] nums, int val) {
        // 用fast遍历所有元素
        // 用slow守住不重复元素的长度，只要有不重复的就给slow
        int slow = 0;
        for(int fast = 0; fast < nums.length; fast++){
            // 如果fast位置和val相等，直接跳过，fast++
            // 如果不相等，则让slow=fast，这样slow永远指向的就是所有不同的元素
            if(nums[fast] != val){
                nums[slow] = nums[fast];
                slow++;
            }
        }
        return slow;
    }
}

力扣977-有序数组的平方
思路：本身就是顺序的数组有可能含有负数，这样平方后的最大数肯定从两头产生，
1、建了一个新数组，将首尾相比最大者放入新数组的最后
2、此时需要一个新数组的索引，从后向前填入新数据

import java.util.*;
public class Solution {
    public int[] sortedArray (int[] nums) {
        // write code here
        int n = nums.length;
        int[] res = new int[n];
        if(n==0) return null;
        int i = 0;
        int j = n-1;
        int tmp = n-1;
        while(i<=j){
            if(nums[i]*nums[i] > nums[j]*nums[j]){
                res[tmp] = nums[i]*nums[i];
                i++;
                tmp--;
            }else{
                res[tmp] = nums[j]*nums[j];
                j--;
                tmp--;
            }
        }
        return res;
    }
}

链接：力扣209-长度最小的子数组
思路：用双层循环去模拟一个滑动窗口，自适应的计算当前这个窗口内连续数组的和
1、j的循环要从i开始，而不能从0开始
2、要在中间设置一个数暂时记录当前数组的和
3、要将最初始的res赋值成最大值
4、当前子数组的长度 j-i+1
5、每次子数组和大于等于target时，都要取个最小的长度

class Solution {
    public int minSubArrayLen(int target, int[] nums) {
        int res = Integer.MAX_VALUE;
        for(int i = 0; i < nums.length; i++){
            // 记录当前遍历过的数的和 与 target比较
            int tmp = 0; 
            for(int j = i; j < nums.length; j++){
                tmp += nums[j];
                if(tmp >= target){
                    res = Math.min(res,j-i+1);
                }
            }
        }
        return res;
    }
}