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

最新推荐文章于 2024-06-12 10:00:23 发布

柚子呀

最新推荐文章于 2024-06-12 10:00:23 发布

阅读量164

点赞数

分类专栏： Java学习文章标签： leetcode 算法数据结构

本文链接：https://blog.csdn.net/LS9811/article/details/125904691

版权

Java学习专栏收录该内容

5 篇文章 0 订阅

订阅专栏

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

给你一个按照非递减顺序排列的整数数组 nums，和一个目标值 target。请你找出给定目标值在数组中的开始位置和结束位置。

如果数组中不存在目标值 target，返回 [-1, -1]。

你必须设计并实现时间复杂度为 O(log n) 的算法解决此问题。

Bug代码

class Solution {
    public int[] searchRange(int[] nums, int target) {
        int firstIndex = serchFirst(nums, target);
        int lastIndex = serchLast(nums, target);
        return new int[] {firstIndex, lastIndex}; 
    }

    private int serchFirst(int[] nums, int target){
        int l = 0, r = nums.length - 1;
        while(l <= r){
            int mid = (r - l) / 2 + l;
            int num = nums[mid];
            if(target == num){
                int min = nums[mid - 1];
                if(mid == 0 || min != target){
                    return mid;
                }
                else{
                    mid= mid -1;
                }
            }
            else if(target < num){
                r = mid - 1;
            }
            else{
                l = mid + 1;
            }
        }
        return -1;
    }

    private int serchLast(int[] nums, int target){
        int l = 0, r = nums.length - 1;
        while(l <= r){
            int mid = (r - l) / 2 + l;
            int num = nums[mid];
            if(target == num){
                int max = nums[mid + 1];
                if(mid == nums.length - 1 || max != target){
                    return mid;
                }
                else{
                    mid = mid + 1;
                }
            }
            else if(target < num){
                r = mid - 1;
            }
            else{
                l = mid + 1;
            }
        }
        return -1;
    }
}

一直超出时间限制

修改后代码

class Solution {
    public int[] searchRange(int[] nums, int target) {
        int firstIndex = serchFirst(nums, target);
        int lastIndex = serchLast(nums, target);
        return new int[] {firstIndex, lastIndex}; 
    }

    private int serchFirst(int[] nums, int target){
        int l = 0, r = nums.length - 1;
        while(l <= r){
            int mid = (r - l) / 2 + l;
            int num = nums[mid];
            if(target == num){
                int min = nums[mid - 1];
                if(mid == 0 || min != target){
                    return mid;
                }
                else{
                    r = mid -1;//继续使用二分法查找！
                }
            }
            else if(target < num){
                r = mid - 1;
            }
            else{
                l = mid + 1;
            }
        }
        return -1;
    }

    private int serchLast(int[] nums, int target){
        int l = 0, r = nums.length - 1;
        while(l <= r){
            int mid = (r - l) / 2 + l;
            int num = nums[mid];
            if(target == num){
                int max = nums[mid + 1];
                if(mid == nums.length - 1 || max != target){
                    return mid;
                }
                else{
                     l = mid + 1;
                }
            }
            else if(target < num){
                r = mid - 1;
            }
            else{
                l = mid + 1;
            }
        }
        return -1;
    }
}

在判断if(mid == 0 || min != target)后，若不满足条件，应该继续使用二分法查找
自己本来用的相当于遍历，不满足时间复杂度要求！