LeetCode_Day1 | 关于数组双指针及二分法查询

小骄傲_

已于 2023-06-06 23:43:36 修改

阅读量408

点赞数

分类专栏：坚持学算法文章标签： leetcode 算法数据结构 java

于 2023-05-14 16:22:44 首次发布

本文链接：https://blog.csdn.net/qq_41833455/article/details/130614453

版权

坚持学算法专栏收录该内容

8 篇文章 0 订阅

订阅专栏

LeetCode_数组

704.二分查找
27.移除元素

704.二分查找

1.题目描述

给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1。
示例：
输入: nums = [-1,0,3,5,9,12], target = 9
输出: 4
解释: 9 出现在 nums 中并且下标为 4

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

详情LeetCode题链接：https://leetcode.cn/problems/binary-search/

2. 做题前要想明白什么

注：本题前提已满足数组为有序数组，同时题目还强调数组中无重复元素，满足以上两点即可以使用二分查找法。

因为数组内一旦有重复元素，使用二分查找法返回的元素下标可能不是唯一的，这些都是使用二分法的必要前提。

二分法的整体思想实际就是不断的循环区间，如何确定边界是重点。 比如到底是while(left < right) 还是 while (left <= right) ,是right = mid ，还是right = mid - 1？
首先要理解区间的定义，区间定义就是不变量。
在二分查找的过程中，要保持不变量，即在while寻找中每一次边界的处理都要坚持根据区间的定义来操作，这就是循环不变量规则。

比如采用左闭右闭区间时，通过对比中间值和target值要确定下一次查找区间，那么下一次的查找区间也是左闭有闭区间。
区间的定义一般为两种，左闭右闭即[left, right]，或者左闭右开即[left, right)。
个人理解：左闭右开和左闭右闭相比可以理解为，左闭右闭比左闭右开多一个假想数，如下图：

3. 左闭右闭代码

 /**
     * 思路：二分法的边界值是重点，灵魂是如何考虑区间，常用区间：
     * 左闭右闭：[left,right],即当left=right是也成立，比如[1,1]所以边界可设为while(left<=right);当nums[mid]>target时，因为此时是右闭区间，此
     *          区间是包含右边的值的，所以当nums[mid]已经大于target了，所以nums[mid]一定不是target，right=mid-1；
     * 左闭右开：[left,right）,即当left=right不成立，比如[1,1)所以边界可设为while(left<right);当nums[mid]>target时，因为此时是右开区间，此
     *          区间是不包含右边的值的，所以当nums[mid]已经大于target了，所以nums[mid]一定不是target，right=mid；
     *
     * 本次实现采用左闭右闭区间写法
     * 时间复杂度O(logn),空间复杂度O(1)
     */
    public int search(int[] nums, int target) {
        //避免当target不存在于有序数组nums中造成多次循环运算
        if (target < nums[0] || target > nums[nums.length -1]) {
             return -1;
        }
        int left = 0, right = nums.length - 1;
        while (left<=right){
            int mid = left + ((right - left) >> 1);
            if (nums[mid] == target) 
                return mid;
            else if (nums[mid] > target)
                right = mid - 1;
            else if (nums[mid] < target)
                left = mid + 1; 
        }
        return -1;
    }

4.左闭右开代码

 /**
     * 思路：二分法的边界值是重点，灵魂是如何考虑区间，常用区间：
     * 左闭右闭：[left,right],即当left=right是也成立，比如[1,1]所以边界可设为while(left<=right);当nums[mid]>target时，因为此时是右闭区间，此
     *          区间是包含右边的值的，所以当nums[mid]已经大于target了，所以nums[mid]一定不是target，right=mid-1；
     * 左闭右开：[left,right）,即当left=right不成立，比如[1,1)所以边界可设为while(left<right);当nums[mid]>target时，因为此时是右开区间，此
     *          区间是不包含右边的值的，所以当nums[mid]已经大于target了，所以nums[mid]一定不是target，right=mid；
     *
     * 本次实现采用左闭右开区间写法
     * 时间复杂度O(logn),空间复杂度O(1)
     */
    public int search(int[] nums, int target) {
        //避免当target不存在于有序数组nums中造成多次循环运算
        if (target < nums[0] || target > nums[nums.length -1]) {
             return -1;
        }
        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)
                right = mid;
            else if (nums[mid] < target)
                left = mid + 1; 
        }
        return -1;
    }

5. 关于中间值溢出问题

通常中间值一般写法： mid = (right+left)/2；
考到溢出和效率后优化使用： mid = (right-left) >>1+left
解释：
(right-left)/2+left 和 (right-left)>>1+left 都是用来计算两个数 left 和 right 之间的中点。

它们都等价于 (right+left)/2。但是 (right-left)>>1+left 使用位移运算代替了除以 2，效率高一点。而且前面两种写法可以避免 int 溢出。

6. 图解举例(左闭右闭)

例如输入: nums = [-1,0,3,5,9,12], target = 9
在这里插入图片描述

27.移除元素

1. 题目描述

给你一个数组 nums 和一个值 val，你需要原地移除所有数值等于 val 的元素，并返回移除后数组的新长度。

不要使用额外的数组空间，你必须仅使用 O(1) 额外空间并原地修改输入数组。

元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。

示例 1: 给定 nums = [3,2,2,3], val = 3, 函数应该返回新的长度 2, 并且 nums 中的前两个元素均为 2。你不需要考虑数组中超出新长度后面的元素。

详情LeetCode题链接： https://leetcode.cn/problems/remove-element/

2. 暴力法

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

采用暴力解法，两层for循环，一个for循环遍历数组元素，第二个for循环更新数组

代码逻辑：

/**
     * 思路：
     *     数组的元素在内存地址中是连续的，不能单独删除数组中的某个元素，只能覆盖.
     *     采用暴力解法，两层for循环，一个for循环遍历数组元素 ，第二个for循环更新数组 
     * 时间复杂度：O(n^2)
     * 空间复杂度：O(1)   
     */
    public int removeElement(int[] nums, int val) {
        int len = nums.length;
        for (int i = 0; i < len; i++){
            if (nums[i] == val){
                for (int j = i + 1; j< len; j++){
                    nums[i] = nums[j];
                }
                i --;
                len --;
            }
        }
        return len;
    }

3. 快慢指针法

双指针法（快慢指针法）：通过一个快指针和慢指针在一个for循环下完成两个for循环的工作。

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

代码逻辑：

 /**
     * 思路：快慢指针法
     *     数组的元素在内存地址中是连续的，不能单独删除数组中的某个元素，只能覆盖.
     *     通过一个快指针和慢指针在一个for循环下完成两个for循环的工作
     *     快指针：寻找新数组的元素 ，新数组就是不含有目标元素的数组
     *     慢指针：指向更新 新数组下标的位置
     * 时间复杂度：O(n)
     * 空间复杂度：O(1)   
     */
    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;
    }

4. 双向双指针法

因为不考虑新数组内的顺序，可用相向双指针法

代码实现逻辑：

/**
     * 思路：相向双指针法(因为不考虑新数组内的顺序，可用相向双指针法)
     *     数组的元素在内存地址中是连续的，不能单独删除数组中的某个元素，只能覆盖.
     *     通过一个快指针和慢指针在一个for循环下完成两个for循环的工作
     *     右指针：寻找新数组的元素 ，新数组就是不含有目标元素的数组
     *     左指针：指向更新 新数组下标的位置
     * 时间复杂度：O(n)
     * 空间复杂度：O(1)   
     */
    public int removeElement(int[] nums, int val) {
        int left = 0;
        int right = nums.length -1;
        //因为不考虑新数组内的顺序，将right移到从右数第一个值不为val的位置
        while (right >= 0 && nums[right] == val) {
            right --;
        }
        //因为不考虑新数组内的顺序，将right位置的元素移到left（覆盖），right位置移除
        while (left <= right){
            if (nums[left] == val){
                nums[left] = nums[right];
                right --;
            }
            left ++;
            while (right >= 0 && nums[right] == val){
                right --;
            }
        }
        return left;
    }