代码随想录算法day01| 数组part1|704. 二分查找、27. 移除元素

数组理论基础

数组是非常基础的数据结构，在面试中，考察数组的题目一般在思维上都不难，主要是考察对代码的掌控能力。

也就是说，想法很简单，但实现起来 可能就不是那么回事了。

数组在内存中的存放方式：

        数组是存放在连续内存空间上的相同类型数据的集合。数组可以方便的通过下标索引的方式获取到下标对应的数据。

数组特征：

        1、数组下标都是从0开始

        2、数组的内存空间地址是连续的——>所以我们在删除或者增添元素的时候，就难免要移动其他元素的地址。

                在C++语言中，二维数组的地址是一行接着一行连续的；

                在Java中，因为虚拟机对地址的封装导致我们没法实际看到地址的连续性，大概率猜测Java中二维数组地址是以行为单位连续，但是行与行之间不一定相连

        3、数组的元素是不能删的，只能覆盖。

704. 二分查找

自己写的代码：

class Solution {
    public int search(int[] nums, int target) {
        int left = 0;
        int right = nums.length-1;
        int middle = left+((right - left)/2);
        while(left <= right){
            if(nums[middle] < target){
                left = middle + 1;
            }else if(nums[middle] > target){
                right = middle - 1;
            }else{
                return middle;
            }
        }
        return -1;
    }
}

结果：超出时间限制

原因：把middle的定义和计算定义在了循环外部，这样会导致middle一直无法更新，一直在循环第一个循环里的东西

第一种写法：我们定义 target 是在一个在左闭右闭的区间里，也就是[left, right] （这个很重要非常重要）

有如下两点：

• while (left <= right) 要使用 <= ，因为left == right是有意义的，所以使用 <=
• if (nums[middle] > target) right 要赋值为 middle - 1，因为当前这个nums[middle]一定不是target，那么接下来要查找的左区间结束下标位置就是 middle - 1

class Solution {
    public int search(int[] nums, int target) {
        int left = 0;
        int right = nums.length-1;
        while(left <= right){
            int middle = left+((right - left)/2);
            if(nums[middle] < target){
                left = middle + 1;
            }else if(nums[middle] > target){
                right = middle - 1;
            }else{
                return middle;
            }
        }
        return -1;
    }
}

        时间复杂度：O(logn)

        空间复杂度：O(n)

区别：把middle的定义和计算从循环外挪到了循环内部

原因：这样会导致middle一直无法更新，一直在循环第一个循环里的东西

第二种写法：定义 target 是在一个在左闭右开的区间里，也就是[left, right) ，那么二分法的边界处理方式则截然不同

有如下两点：

• while (left < right)，这里使用 < ,因为left == right在区间[left, right)是没有意义的
• if (nums[middle] > target) right 更新为 middle，因为当前nums[middle]不等于target，去左区间继续寻找，而寻找区间是左闭右开区间，所以right更新为middle，即：下一个查询区间不会去比较nums[middle]

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 { // nums[mid] > target
                right = mid;
            }
        }
        // 未找到目标值
        return -1;
    }
}

区别：middle计算中的/2，这里采用位运算，速度更快

27. 移除元素

第一种解法：暴力解法

两层for循环，一个for循环遍历数组元素 ，第二个for循环更新数组

// 时间复杂度：O(n^2)
// 空间复杂度：O(1)
class Solution {
public:
    int removeElement(vector<int>& nums, int val) {
        int size = nums.size();
        for (int i = 0; i < size; i++) {
            if (nums[i] == val) { // 发现需要移除的元素，就将数组集体向前移动一位
                for (int j = i + 1; j < size; j++) {
                    nums[j - 1] = nums[j];
                }
                i--; // 因为下标i以后的数值都向前移动了一位，所以i也向前移动一位
                size--; // 此时数组的大小-1
            }
        }
        return size;

    }
};

注意重点：

        当所有数组元素都往前移了一格之后，下标i也需要往前移动一格，因为当前i下标中的元素已经是未比对的元素，需要重新进行比对。

第二种解法：双指针法（快慢指针法）

通过一个快指针和慢指针在一个for循环下完成两个for循环的工作

双指针法（快慢指针法）在数组和链表的操作中是非常常见的，很多考察数组、链表、字符串等操作的面试题，都使用双指针法

定义快慢指针

• 快指针：寻找新数组的元素 ，新数组就是不含有目标元素的数组
• 慢指针：指向更新 新数组下标的位置

讲人话就是：一个指针指的是最终返回的没有指定元素的数组的最后一个元素下标，另一个指针去搜索不是指定元素的元素；也就是说，第一种解法在寻找指定元素，而快慢指针在寻找非指定元素

class Solution {
    public 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];
                slowIndex++;
            }
        }
        return slowIndex;
    }
}

第三种解法：双向指针法

类似于快慢指针，也是将其中一个指针(一般是left指针)定义为指向最终返回的数组的最后一个元素的下标，同时判断此时指向元素是否为指定元素，另一个指针(right)不断寻找非指定元素，覆盖给left指针的指定元素，最终完成left指针指向下标之前的数组为所求数组，即全非指定元素数组

第一种写法：

//相向双指针法
class Solution {
    public int removeElement(int[] nums, int val) {
        int left = 0;
        int right = nums.length - 1;
        while(right >= 0 && nums[right] == val) right--; //将right移到从右数第一个值不为val的位置
        while(left <= right) {
            if(nums[left] == val) { //left位置的元素需要移除
                //将right位置的元素移到left（覆盖），right位置移除
                nums[left] = nums[right];
                right--;
            }
            left++;
            while(right >= 0 && nums[right] == val) right--;
        }
        return left;
    }
}

第二种写法：

这种写法融合了第一种暴力解法的元素左移覆盖的时候，将left指针也左移的想法，用这一种情况兼容了right指针指向指定元素的情况，一视同仁的在left指针处检查

// 相向双指针法（版本二）
class Solution {
    public int removeElement(int[] nums, int val) {
        int left = 0;
        int right = nums.length - 1;
        while(left <= right){
            if(nums[left] == val){
                nums[left] = nums[right];
                right--;
            }else {
                // 这里兼容了right指针指向的值与val相等的情况
                left++;
            }
        }
        return left;
    }
}

总结：

二分问题

1、上手第一件事情就是明确区间定义，无论是左闭右闭还是左闭右开，只是要明确每次收缩范围后、范围内的元素是哪些 、注意会不会漏掉边界就好

2、需要注意二分的几种情况

        （1）当l = 0, r = n的时候因为r这个值我们在数组中无法取到,while(l < r) 是正确写法

        （2）当l = 0, r = n - 1的时候因为r这个值我们在数组中可以取到,while(l <= r) 是正确写法 主要看能不能取到这个值

3、二分的最大优势是在于其时间复杂度是O(logn)，因此看到有序数组都要第一时间反问自己是否可以使用二分

4、关于为什么middle用到 left + (right - left) / 2 而不是 (left + right) / 2 是因为存在一个防溢出的情况：当mid = (l + r) / 2时，如果l + r 大于 INT_MAX(C++内，就是int整型的上限)，那么就会产生溢出问题（int类型无法表示该数）

5、对于二进制的正数来说，右移x位相当于除以2的x几次方，所以右移一位等于➗2，用位运算的好处是比直接相除的操作快

移除元素

1、快指针可以理解成在旧数组中找非目标元素，然后赋值给慢指针指向的新数组