leetCode01数组-二分法、双指针

透过胶体的晨曦

已于 2023-06-10 10:07:20 修改

阅读量551

点赞数

文章标签：算法 leetcode

于 2023-04-19 19:01:51 首次发布

本文链接：https://blog.csdn.net/dawn114b/article/details/130247176

版权

文章详细介绍了二分查找算法在不同区间定义下的实现，包括左闭右闭和左闭右开的情况，并展示了如何应用二分查找解决搜索插入位置、在排序数组中查找元素的第一个和最后一个位置的问题。此外，还讨论了两种方法来移除数组中的指定元素，一种是双循环解法，另一种是双指针策略。

摘要由CSDN通过智能技术生成

704二分查找

704. 二分查找

二分法使用前提是没有重复数据。

两种区间定义，[left, right]，[left, right)。

[left, right]

left = 0，right = size - 1，左右均可以取到。

while条件小于等于，左右闭则有相等的可能。

更改左右区间取right = middle - 1或left = middle + 1。

class Solution {
    public int search(int[] nums, int target) {
        //查中间索引值大小//比较//再次寻找中间等于一段返回-1
        int left = 0;
        int right = nums.length - 1;

        if(nums[right] == target)return right;
        if(nums[left] == target)return left;
        while(left <= right){
        int middle = (right-left)/2 + left;//防止溢出
            if(target > nums[middle]){
                left = middle + 1;
            }else if(target < nums[middle]){
                right = middle - 1;
            }else{
                return middle;
            }
        }
        return -1;
        }
    }

[left, right)

left = 0，right = size ，左可以取到,右边是取不到的。

while条件小于等于，左右闭则有相等的可能。

更改左右区间取right = middle - 1或left = middle + 1。

class Solution {
    public int search(int[] nums, int target) {
        //查中间索引值大小//比较//再次寻找中间等于一段返回-1
        int left = 0;
        int right = nums.length;


        if(nums[left] == target)return left;

        while(left < right){
        int middle = (right-left)/2 + left;//防止溢出
            if(target > nums[middle]){
                left = middle + 1;//左闭，left仍然要middle+1
            }else if(target < nums[middle]){
                right = middle;//右开，right这个值取不到的
            }else{
                return middle;
            }
        }
        return -1;
        }
    }

搜索插入位置

35. 搜索插入位置

就是返回值改一下,返回left。与左闭右开、左闭右闭无关

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

34. 在排序数组中查找元素的第一个和最后一个位置

class Solution {
    int[] searchRange(int[] nums, int target) {
        //初始化为-1，没被修改说明target不在区间内
        
        //分别寻找左右
        int leftBorder = findLeft(nums,target);
        int rightBorder = findRight(nums,target);
        if(leftBorder == -2 || rightBorder == -2)return new int[]{-1,-1};//target值不在区间内

        if(- leftBorder  + rightBorder > 1)return new int[]{leftBorder + 1,rightBorder - 1};
        return new int[]{-1,-1};//target没在区间内出现
    }
    public int findLeft(int[]nums,int target){
        int leftBorder = -2;
        int left = 0;
        int right = nums.length - 1;
        while(left <= right){
            int mid = (right - left) / 2 + left;
        //左边界更新靠的是right。
            if(nums[mid] >= target){
                right = mid - 1;
                leftBorder = right;
            }else{
                left = mid + 1;
            }
        }
        return leftBorder;
    }
    public int findRight(int[]nums,int target){
        int rightBorder = -2;
        int left = 0;
        int right = nums.length - 1;
        while(left <= right){
            int mid = (right - left) / 2 + left;
        //左边界更新靠的是right。
            if(nums[mid] > target){
                right = mid - 1;
        
            }else{
                left = mid + 1;
                rightBorder = left;
            }
        }
        return rightBorder;
    }
}

27. 移除元素

双循环解法

class Solution {
    public int removeElement(int[] nums, int val) {
        //暴力求解
        int length = nums.length;
        for(int i = 0;i < length ;i++){
            if(val == nums[i]){

                for(int j = i;j < length -1 ;j++){
                    nums[j] = nums[j + 1];
                }
                length--;
                i--;//如果连续两个重复的值则会错过一个 如 1223，删除第一个2后内循环将数据前移，i不回退会错过数值。
            }
        }
        return length;
    }
}

双指针

遇到目标值，快指针移动，慢指针不移动。

不是目标值，快指针指向的值赋值给慢指针，快慢指针都前移。

class Solution {
    public int removeElement(int[] nums, int val) {
        //双指针
        int j = 0;
        for(int i = 0;i < nums.length;i++){
            if(nums[i] != val){
                nums[j] = nums[i];
                j++;
            }
        }
        return j;
    }
}