代码随想录|第一章，数组

【1】704.二分查找

//左闭右闭 while (left <= right)
class Solution {
    public int search(int[] nums, int target) {
        // 避免当 target 小于nums[0] nums[nums.length - 1]时多次循环运算
        if (target < nums[0] || target > nums[nums.length - 1]) {
            return -1;
        }
        int left = 0, right = nums.length - 1;
        while (left <= right) {
            int mid = left + ((right - left) >> 1);
            if (nums[mid] == target)  //此处是nums[mid],错写成mid
                return mid;
            else if (nums[mid] < target)
                left = mid + 1;
            else if (nums[mid] > target)
                right = mid - 1;
        }
        return -1; //这个地方容易忘掉
    }
}
//左闭右开 while (left < right)
class Solution {
    public int search(int[] nums, int target) {
        int left = 0, right = nums.length;
        while (left < right) {
            int mid = left + ((right - left) >> 1);
            if (nums[mid] == target)
                return mid;
            else if (nums[mid] < target)
                left = mid + 1;
            else if (nums[mid] > target)
                right = mid;
        }
        return -1; //这个地方容易忘掉
    }
}

1.没有考虑数据不合法的情况：

if（target<num[0] || targer>nums[nums.length-1]）{
    return -1;
}

2.使用的是while循环而不是for循环：

//[ ]
while(left<=right){}

//[ )
while(left<right){}

3.  >>1 相当于/2

 int mid = left + ((right - left) >> 1);

【2】27.移除元素

class Solution {
    public int removeElement(int[] nums, int val) {
        // 快慢指针
        int slowIndex = 0;
        for (int fastIndex = 0; fastIndex < nums.length; fastIndex++) { 
             // 1.记得int fastIndex;2.fastIndex<num.length
            if (nums[fastIndex] != val) {
                nums[slowIndex] = nums[fastIndex];
                slowIndex++;
            }//if条件句下面执行两个语句，记得加{}
        }
        return slowIndex;//返回慢指针，就是新数组的长度。
    }
}

1.

//最后返回的是指针：return slow;我写成： return nums[slow] ;

return slow;

【3】977.有序数组的平方

class Solution{
    public int[] sortedSquares(int [] nums){
        int i=0;
        int j=nums.length-1;
        int []result =new int[nums.length];//定义数组的方法
        int k=result.length-1;
        while(i<=j){
            if(nums[i]*nums[i]>nums[j]*nums[j]){
                result[k]=nums[i]*nums[i];
                k--;
                i++;
            }
            else{
                result[k]=nums[j]*nums[j];
                k--;
                j--;
            }
        }
        return result;//返回数组
    }

}

【4】209.长度最小的子数组

//思路：滑动窗口。
//暴力解法时间复杂度：O(n^2)
//滑动窗口时间复杂度：O(n)
//本题中，主要要理解滑动窗口如何移动 窗口起始位置，达到动态更新窗口大小的，从而得出长度最小的符合条件的长度。
//滑动窗口的精妙之处在于根据当前子序列和大小的情况，不断调节子序列的起始位置。从而将O(n^2)的暴力解法降为O(n)。
class Solution {
    public int minSubArrayLen(int target, int[] nums) {
        int i=0;//窗口左边界
        int j=0;//窗口右边界
        int sum=0;//窗口的和
        int minlen=Integer.MAX_VALUE;//定义最小数组长度并初始化为无穷大
        for(j=0;j<nums.length;j++){//右指针向右移动
            sum+=nums[j];

            while(sum>=target){//当sum>=target时，左指针一直向左移动
                minlen=Math.min(minlen,j-i+1);//更新窗口长度
                sum=sum-nums[i];//更新窗口和
                i++;//左指针向左移动
            }

        }
        if (minlen == Integer.MAX_VALUE)//如果窗口长度为原来的无穷大，返回0
          return 0;
        else{
            return minlen;//返回窗口长度
        }
    }
}