01-数组-二分查找&移除元素

数组理论基础

代码随想录链接

• 在C++中二维数组在地址空间上是连续的，Java二维数组的每一行头结点的地址是没有规则的，更谈不上连续。
• Java数组长度固定，无法删除，只能覆盖
• 复习Java基础，待补充

704.二分查找

题目概述：有序数组，无重复元素，查询目标值的下标。

链接：leetcode704 链接
第一反应——遍历，当然不可能遍历。使用二分查找，时间复杂度O(logn)。注意左闭右开还是都是闭区间。写了这两种解法

public int search(int[] nums, int target) {
        int l = 0;
        int r = nums.length;//左闭右开
        int mid;
        while (l < r){
            mid = l + (r - l)/2;//防止内存泄露
            if (nums[mid] < target){
                l = mid + 1;
            } else if (nums[mid] > target){
                r = mid;
            } else {
                return mid;
            }
        }
        return -1;
    }
    public int search2(int[] nums, int target) {
        int l = 0;
        int r = nums.length - 1;//左右都是闭区间
        int mid;
        while (l <= r){
            mid = l +(r - l)/2;
            if (nums[mid] < target){
                l = mid + 1;
            }else if (nums[mid] > target){
                r = mid - 1;
            }else {
                return mid;
            }
        }
        return -1;
    }

看别人的题解，开始加入了一个判断，是否小于最小值或者大于最大值。

if (target < nums[0] || target > nums[nums.length - 1]) {
            return -1;
        }

27.移除元素

题目概述：原地移除某数值，不使用额外空间

链接：leetcode27链接

1.暴力解法：遍历元素，遇到该数值就删除

手写了一遍暴力解法，第一次出错了。测试用例发现两个连着的目标元素，只能删除一个，发现应该是i++的问题，如果执行了删除元素，i 就不需要+1了。

public int removeElement(int[] nums, int val) {
        int size = nums.length;
        for (int i = 0; i < size; i++) {
            if (nums[i] == val){
                for (int j = i; j < size - 1; j++) {
                    nums[j] = nums[j + 1];
                }
                size--;
            }
        }
        return size;
    }

修改后代码如下，测试通过：

public int removeElement(int[] nums, int val) {
        int size = nums.length;
        int i = 0;
        while (i < size){
            if (nums[i] == val){
                for (int j = i; j < size - 1; j++) {
                    nums[j] = nums[j + 1];
                }
                size--;
            } else {
                i++;
            }
        }
        return size;
    }

2.l和r两个指针，把最后一个补过来，测试通过

    public int removeElement2(int[] nums, int val) {
        int l = 0, r = nums.length - 1;
        while (l <= r){
            if (nums[l] == val){
                nums[l] = nums[r];
                r--;
            } else {
                l++;
            }
        }
        return r + 1;
    }

3.回去看文档发现有快慢指针解法，写了一遍：

public int removeElement3(int[] nums, int val) {
        int slow = 0;
        for (int fast = 0; fast < nums.length; fast++) {
            if (nums[fast] != val){
                nums[slow] = nums[fast];
                slow++;//slow指向的是待填充的位置
            }
        }
        return slow;
    }

总结

这些内容之前看过，也比较简单，但是还是存在一些想不到的地方，比如暴力解法一不小心就容易出错。

拓展题目

35.搜索插入位置

和二分法相同，只不过要考虑一下没有找到时返回什么。
以左右都是闭区间为例，最后一次执行循环应当是l = r = mid，此时如果mid位置的值比target小，插入到mid后面，而l正好执行了 +1 操作，比target大，就插入到当前位置，也是l。
左闭右开也是同样思考。

public int searchInsert(int[] nums, int target) {
        int l = 0, r = nums.length -1;//左右都是闭区间
        int mid;
        while (l <= r){
            mid = l + (r - l)/2;
            if (nums[mid] < target){
                l = mid + 1;
            } else if (nums[mid] > target){
                r = mid - 1;
            } else {
                return mid;
            }
        }
        return l;
    }
    public int searchInsert2(int[] nums, int target) {
        int l = 0, r = nums.length;//左闭右开
        int mid;
        while (l < r){
            mid = l + (r - l) / 2;
            if (nums[mid] < target){
                l = mid + 1;
            } else if (nums[mid] > target){
                r = mid;
            } else {
                return mid;
            }
        }
        return l;
    }