Question

情境：

我有一个名为“searchRange”的方法，我需要在提供的输入数组中搜索目标发生的最小和最大索引。

问题：

我认为这个解决方案的时间复杂度是O（n）因为我只在输入上循环一次。我的理解是否正确？

代码：

public class Solution {

    public int[] searchRange(int[] nums, int target) {
        if (nums == null) {
            return new int[2];
        }
        int min = -1, max = -1, l = nums.length;
        int[] ans = new int[2];
        for (int i = 0; i < l; i++) {
            if (nums[i] == target) {
                if (min == -1) {
                    min = i;
                } else {
                    max = Math.max(i, max);
                }
            }
        }
        if (min != -1 && max == -1) {
            max = min;
        }
        ans[0] = min;
        ans[1] = max;
        return ans;
    }
}

修改

谢谢，我现在知道上述算法的时间复杂度是O（n）。我正试图达到O（logn）。我尝试使用二进制搜索的变体来发现最小和最大索引。该方法的时间复杂度是否低于O（logn）？

public int[] searchRange(int[] nums, int target) {
    if (nums == null)
        return new int[2];
    return searchRange(nums, target, 0, nums.length - 1);
}

public int[] searchRange(int[] nums, int target, int l, int h) {
    int[] ans = new int[] { -1, -1 };
    int middle = (l + h) / 2;
    if (l > h)
        return ans;
    if (nums[middle] == target) {
        if (middle < nums.length - 1 && nums[middle + 1] == target) {
            int[] right = searchRange(nums, target, middle + 1, h);
            ans[1] = right[1];
            ans[0] = middle;
        }
        if (middle >= 1 && nums[middle - 1] == target) {
            int[] left = searchRange(nums, target, l, middle - 1);
            ans[0] = left[0];
            if (ans[1] == -1) {
                ans[1] = middle;
            }
        }
        if (ans[0] == ans[1] && ans[0] == -1) {
            ans[0] = ans[1] = middle;
        }
    } else if (nums[middle] < target) {
        return searchRange(nums, target, middle + 1, h);
    } else {
        return searchRange(nums, target, l, middle - 1);
    }
    return ans;
}

Answer 1

看起来像一个简单的O（n），其中n是输入数组的长度。在每次调用searchRange（）函数时，您将遍历整个数组。

我的解决方案的时间复杂度是多少？

1 个答案: