数组中常见的算法

了解数组的基本概念

数组在内存中的空间是连续的，所以就会导致数组的插入、删除的时间复杂度会很高，我们在删除和插入元素的时候需要移动其他元素来保证数组内存空间的连续。
数组的下标是从0开始的。

二分查找

二分查找就是在有序的数组中，取中间的元素。判断我们要查找的值是大于中间值还是小于中间值还是等于中间值。

力扣704：二分查找

给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1。

解答

解析：因为数组nums是有序的，在有序数组中查找一个目标值，使用二分查找。闭就是±1，开就是等于中间值。一般我们使用的就是左闭右闭或者左闭右开。

左闭右闭

**左闭右闭**
```java
public class lc704 {
    public static void main(String[] args) {
        int[] nums= {-1,0,3,5,9,12};
        int target=9;
        int search = search(nums, target);
        System.out.println(search);
    }
    //左闭右闭
    public static int search(int[] nums, int target) {
        int left=0;//左边界下标
        int right=nums.length-1;//右边界下标
        while (left<=right){
            int mod=(left+right)/2;
            //如果大于
            if(target>nums[mod]){
                left=mod+1;
            }else if (target<nums[mod]){
            //如果小于
                right=mod-1;
            }else return mod;
        }
        return -1;
    }
}

左闭右开

public class lc704 {
    public static void main(String[] args) {
        int[] nums= {-1,0,3,5,9,12};
        int target=9;
        int search = search(nums, target);
        System.out.println(search);
    }
    //左闭右开
    public static int search(int[] nums, int target) {
        int left=0;//左边界下标
        int right=nums.length;//右边界下标
        while (left<right){
            int mod=(left+right)/2;
            //如果大于
            if(target>nums[mod]){
                left=mod+1;
            }else if (target<nums[mod]){
                right=mod;//因为区别本来就不包含右边界的值，如果减1的话会漏掉一个数
            }else return mod;
        }
        return -1;
    }
}

快慢指针

因为数组中的内存空间是连续的，移除元素就相当于是进行了覆盖。

力扣16：移除元素

• 给你一个数组 nums 和一个值 val，你需要 原地 移除所有数值等于 val 的元素。元素的顺序可能发生改变。然后返回 nums 中与 val 不同的元素的数量。

  假设 nums 中不等于 val 的元素数量为 k，要通过此题，您需要执行以下操作：

  • 更改 nums 数组，使 nums 的前 k 个元素包含不等于 val 的元素。nums 的其余元素和 nums 的大小并不重要。
  • 返回 k。

解答

解析：有一个数组和一个值val，删除数组中等于val的数值。可以采用双指针中的快慢指针进行解决。

public class lc27 {
    public static void main(String[] args) {
        int[] nums= {3,2,2,3};
        int target=3;
        int search = removeElement(nums, target);
        System.out.println(search);
    }

    public static int removeElement(int[] nums, int val) {
        //先定义快慢指针
        int slowIndex = 0;//慢指针
        for (int fastIndex = 0; fastIndex < nums.length; fastIndex++) {//快指针
            //如果找到了目标值就进行覆盖
            if(nums[fastIndex]!=val){
                nums[slowIndex++]=nums[fastIndex];
            }
        }
        return slowIndex;
    }
}

左右指针

左右指针对应的元素进行比较。

力扣911：有序数组的平方

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

解答

解析：nums是一个非递减的整数数组，要返回每一个数的平方组成的新数组。

1. 首先我们要创建一个新数组来存放每个数字的平方
2. 最大值只会出现在左边界或者右边界

public class lc911 {
    public static void main(String[] args) {
        int[] nums= {-4,-1,0,3,10};
        int[] search = sortedSquares(nums);
        for (int i = 0; i < search.length; i++) {
            System.out.println(search[i]);
        }
    }
    public static int[] sortedSquares(int[] nums) {
        int left=0;//左边界
        int right=nums.length-1;//右边界
        int k=nums.length;
        int[] result=new int[k];
        //当左边界大于右边界的时候停止
        while (left<=right){
            if (nums[left]*nums[left]>nums[right]*nums[right]){
                result[--k]=nums[left]*nums[left++];
            }else {
                result[--k]=nums[right]*nums[right--];
            }
        }
        return result;
    }
}

滑动窗口

滑动窗口一般就是解决查找子数组或者子序列的问题，通过不断移动窗口的启示位置来进行获取。

力扣209：长度最小的子数组

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

找出该数组中满足其总和大于等于 target 的长度最小的

子数组

[numsl, numsl+1, ..., numsr-1, numsr] ，并返回其长度**。**如果不存在符合条件的子数组，返回 0 。

解答

解析：要找出数组中的子数组，首先想到滑动窗口。要找到子数组中总和大于等于target的最小长度。

public class lc209 {
    public static void main(String[] args) {
        int[] nums= {1,1,1,1,1,1,1,1};
        int target=11;
        int search = minSubArrayLen(target,nums);
        System.out.println(search);
    }
    public static int minSubArrayLen(int target, int[] nums) {
        int start=0;//起始位置
        int end=0;//终止位置
        int sum=0;//子数组总和
        int result=Integer.MAX_VALUE;//记录最小长度
        for (end = 0; end < nums.length;end++) {
            sum+=nums[end];
            while (sum>=target){
                result=Math.min(end-start+1,result);
                sum-=nums[start++];
            }
        }
        return result ==Integer.MAX_VALUE ? 0 : result;//如果还是等于Integer.MAX_VALUE，说明整个数组加起来都没有大于target
    }
}