【算法Day1】数组 : 704.二分查找 | 27.移除元素

数组理论基础

题目建议：先了解数组理论基础，知道数组的内存空间地址，数组并不简单。

704 二分查找

leetcode链接：704. 二分查找

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

示例1：

1. 输入: nums = [-1,0,3,5,9,12], target = 9
2. 输出: 4
3. 解释: 9 出现在 nums 中并且下标为 4

示例2：

1. 输入: nums = [-1,0,3,5,9,12], target = 2
2. 输出: -1
3. 解释: 2 不存在 nums 中因此返回 -1

题目特点：给定的数组是升序的且无重复元素

第一想法：根据数组升序的特点每次将数组折半，缩小查找范围：如果查找范围中间元素nums[mid]比目标值target大，说明target在查找范围的左半部分，下一步就在左半部分继续查找；反之则在查找范围的右半部分继续查找，直至找到，返回其索引值。如果最终没有找到则返回-1。

注意细节：先确定查找范围是左闭右闭还是左闭右开 然后确定区间的边界更新

方法1 左闭右闭二分查找

Java代码：

 class Solution {
   public int search(int[] nums, int target) {
        //查找范围左闭右闭 [left,right]
        int left = 0;
        int right = nums.length-1;
        int mid = 0;
        //left可以等于right
        while(left <= right) {
            mid = left + (right - left) / 2;//不写为mid=(l + r)/2是为了防止栈溢出
            //更新查找区间
            if(target == nums[mid]) {
                return mid;
            }
            else if(target < nums[mid]) {
            
                right = mid - 1;
            }
            else {
                left = mid + 1;
            }
        }
        return -1;
    }
}

方法2 左闭右开二分查找

Java代码：

class Solution {
    public int search(int[] nums, int target) {
         //查找范围左闭右开 [left,right)
        int left = 0;
        int right = nums.length;
        int mid;
        //left不可以等于right 
        while(left < right) {
            mid = left + (right - left) / 2;//不写为mid=(l + r)/2是为了防止栈溢出
            //更新查找区间
            if(target == nums[mid]) {
                return mid;
            }
            else if(target < nums[mid]) {
                right = mid;
            }
            else {
                left = mid + 1;
            }
        }
        return -1;
    }
}

方法3 递归二分查找

当然递归也有左闭右闭和左闭右开的写法，这里我写的是左闭右闭。

Java代码：

class Solution {
    public int search(int[] nums, int target) {
        return search(nums, 0,nums.length - 1, target);
    }
    private static  int search(int[] data, int l, int r, int target) {
        if(l > r) {
            return -1;
        }
        int mid = l + (r - l) / 2;//不写为mid=(l + r)/2是为了防止栈溢出
        if(data[mid] == target) {
            return mid;
        }
        else if(data[mid] < target) {
            //中间元素比所找元素小 说明所找元素在中间元素右边
            return search(data, mid + 1, r, target);
        }
        else {
            //中间元素比所找元素大 说明所找元素在中间元素左边
            return search(data, 0, mid - 1, target);
        }
    }
}

27 移除元素

leetcode链接：27. 移除元素

题目：

• 给你一个数组 nums 和一个值 val，你需要 原地 移除所有数值等于 val 的元素，并返回移除后数组的新长度。
• 不要使用额外的数组空间，你必须仅使用 O(1) 额外空间并 原地 修改输入数组。
• 元素的顺序可以改变。
• 你不需要考虑数组中超出新长度后面的元素。

示例1:

1. 输入：nums = [3,2,2,3], val = 3
2. 输出：2, nums = [2,2]
3. 解释：函数应该返回新的长度 2, 并且 nums 中的前两个元素均为 2。
        你不需要考虑数组中超出新长度后面的元素。
        例如，函数返回的新长度为 2 ，而 nums = [2,2,3,3] 或 
        nums = [2,2,0,0]，也会被视作正确答案。

示例2：

1. 输入：nums = [0,1,2,2,3,0,4,2], val = 2
2. 输出：5, nums = [0,1,4,0,3]
3. 解释：函数应该返回新的长度 5, 并且 nums 中的前五个元素为 0, 1, 3, 0, 4。
   注意这五个元素可为任意顺序。你不需要考虑数组中超出新长度后面的元素。

题目特点：原地移除元素

第一想法：先尝试用两层for循环暴力解法，但是会超出时间内限制。
后面利用左右双指针，左指针left指向数组第一个元素，右指针right指向数组最后一个元素，首先判断left指向的元素是否等于val，如果不想等就left++；如果相等就和right指向的元素交换，right++，再重新判断left所指元素的值。这个过程用while循环去实现。但是一直通过不了，每次的修改都只能通过部分测试用例，写着写着就把自己绕进去了…看了视频数组中移除元素并不容易！ | LeetCode：27. 移除元素
后恍然大悟，数组的元素是不能删的，只能覆盖，所以可以直接把原数组当作新数组，利用快慢指针，首先快慢指针都指向第一个元素，快指针 fast 从头往后 for 循环，如果 fast 所指元素不等于val，就把其值赋给慢指针 slow 所指元素，接着 slow++，循环一遍后数组中不等于val的值就依次覆盖了原数组的值，最后返回前面不等于val的元素的数量即 slow 就可以了！

方法 快慢指针

Java代码：

class Solution {
   //方法：快慢指针
   public int removeElement(int[] nums, int val) {
       int slow = 0;//慢指针
        for(int fast = 0; fast < nums.length; fast++)  {
            if(nums[fast] != val) {//fast所指元素不等于val
                nums[slow] = nums[fast];//把其值赋给慢指针slow所指元素
                slow++;
            }
        }
        return slow;//返回新的数组长度
    }
}

总结

做数组的题目一定要注意边界条件，要维持循环不变量，也要熟练使用双指针、快慢指针的方法去操作数组元素。