1.力扣刷题心得（一）数组

（一） 数组相关

1、数组是存放在连续内存空间上的相同类型数据的集合。

2、二分法只能应用于有序数组。

3、数组多用于频繁使用索引的场合，链表多用于频繁插入删除的场合。

4、链表的存储空间要比相同容量的数组大。

5、防止溢出的写法。有时在比较时数值会超出定义的类型的范围，就可以用防止溢出的写法，如：

int a = 11123;
int b = 123456789;
// 若相比较a的平方与b的大小，可以
if (b/a > a) {}
// 而不是
if (a * a < b) {}

6、数组的元素在内存地址中是连续的，不能单独删除数组中的某个元素，只能覆盖。

（二） 相关算法

1、二分法

二分法只能应用于有序数组。二分法的经典应用是处理有序数组中的某个元素。

时间复杂度为O（log n）

35.搜索插入位置 (力扣)

// 题目：给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。
// 如果目标值不存在于数组中，返回它将会被按顺序插入的位置。

class Solution {
    public int searchInsert(int[] nums, int target) {
        int startNode = 0;  // 数组首索引
        int endNode = nums.length - 1; //数组尾索引
        int mid = 0;
        // 因为循环中startNode到endNode的范围不断减小，所以使用此判断条件
        while (startNode <= endNode) {
            mid = (startNode + endNode) / 2; // 数组中间的索引
            if (nums[mid] == target) 
                return mid;
            else if (nums[mid] < target)
                startNode = mid + 1;   // 确定是在mid左边还是右边，从而缩小区间
            else 
                endNode = mid - 1;
        }
        return startNode;
    }
}

2、双指针法（这个方法非常重要！！！！！）

通过一个快指针一个慢指针达到目的，很多的题都会用到双指针法。

26. 删除有序数组中的重复项

//*
题目：给你一个有序数组 nums ，请你 原地 删除重复出现的元素，使每个元素 只出现一次 ，
返回删除后数组的新长度。
不要使用额外的数组空间，你必须在 原地 修改输入数组 并在使用 O(1) 额外空间的
条件下完成。
*/

class Solution {
    public int removeDuplicates(int[] nums) {
        // 注意题目是有序数组 双指针可以在不创建新的数组的情况下进行元素的移除，
        // 利用fastIndex编写判断条件，选择进入数组中的元素
        int slowIndex = 0; 
        for (int fastIndex = 0; fastIndex < nums.length; fastIndex++) {
            if (fastIndex < 1) {
                nums[slowIndex++] = nums[fastIndex];
            }
            else if (nums[fastIndex] != nums[fastIndex - 1]) {
                nums[slowIndex++] = nums[fastIndex];
            }   
        }
        return slowIndex;
    }
}

有的时候，看待问题的方法，决定了代码的复杂程度！！

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

思路：例如数组

int[] temp = {-4, -1, 0, 3, 6};

如果直接对每个元素平方再排序，那么题目中的有序数组这个条件就忽略了。无疑会增加代码复杂度。

所以换个思路，观察首尾的元素一定是最大的，然后越往中心绝对值越小，所有就可以使用双指针法，从两端出发，比较大小，然后向里靠拢。

class Solution {
    public int[] sortedSquares(int[] nums) {
        int right = nums.length - 1;
        int left = 0;
        int[] result = new int[nums.length];
        int index = result.length - 1;
        while (left <= right) {
            if (nums[left] * nums[left] > nums[right] * nums[right]) {
                result[index--] = nums[left] * nums[left];
                ++left;
            } else {
                result[index--] = nums[right] * nums[right];
                --right;
            }
        }
        return result;
    }
}

3、滑动窗口

这个方法其实就是双指针法（他是多么的重要）。滑动窗口，就是不断的调节子序列的起始位置和终止位置，从而得出我们要想的结果。直接看题。

209. 长度最小的子数组 （力扣）

//* 给定一个含有 n 个正整数的数组和一个正整数 target 。
找出该数组中满足其和 ≥ target 的长度最小的 连续子数组 [numsl, numsl+1, ..., numsr-1, numsr] ，并返回其长度。如果不存在符合条件的子数组，返回 0 。
*/
class Solution {

    // 滑动窗口
    // 注意是寻找连续数组，所以用到了滑动窗口
    public int minSubArrayLen(int s, int[] nums) {
        int left = 0;
        int sum = 0;
        int result = Integer.MAX_VALUE;
        for (int right = 0; right < nums.length; right++) {
            sum += nums[right];
            while (sum >= s) {
                result = Math.min(result, right - left + 1);
                sum -= nums[left++];
            }
        }
        return result == Integer.MAX_VALUE ? 0 : result;
    }
}

转自：代码随想录

这里还是以题目中的示例来举例，s=7， 数组是 2，3，1，2，4，3，来看一下查找的过程：