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

场景：

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;
    }
}

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

问题：

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），因为我只在输入上循环一次。我的理解正确吗

代码：

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;
    }
}

公共类解决方案{
公共int[]搜索范围（int[]nums，int目标）{
如果（nums==null）{
返回新整数[2]；
}
int min=-1，max=-1，l=nums.length；
int[]ans=新的int[2]；
对于（int i=0；i

编辑

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

public int[]searchRange（int[]nums，int-target）{
如果（nums==null）
返回新整数[2]；
返回搜索范围（nums，目标，0，nums.length-1）；
}
公共int[]搜索范围（int[]nums，int目标，int l，int h）{
int[]ans=新的int[]{-1，-1}；
中间整数=（l+h）/2；
如果（l>h）
返回ans；
if（nums[中间]==目标）{
if（中间=1&&nums[middle-1]==target）{
int[]left=搜索范围（nums，target，l，middle-1）；
ans[0]=左[0]；
如果（ans[1]==-1）{
ans[1]=中间；
}
}
如果（ans[0]==ans[1]&&ans[0]==-1）{
ans[0]=ans[1]=中间；
}
}else if（nums[中间]<目标）{
返回搜索范围（nums，目标，中间+1，h）；
}否则{
返回搜索范围（nums、target、l、middle-1）；
}
返回ans；
}

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

您应该考虑当输入由负数小于<代码> -1 时会发生什么。我不认为它是输入。它是找到

target

的位置的数组索引。他正在记录目标号码的第一个和最后一个索引<代码>-1是数组索引的不可能值。该代码有效吗？你测试过了吗？你有正确的想法去进行二进制搜索以达到O（logn）。这是O（logn），假设你的输入数组已经排序，而你的初始版本不需要排序。因此，总的来说，这应该是一个比以前更好的解决方案，具体取决于如何获得排序数组。它是O（logn），因为每次递归调用都要处理数组的一半。数组排序了吗？如果对数组进行排序，则可以通过二进制搜索轻松确定get O（logn）。