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

【问题标题】：What is the time complexity of my solution?我的解决方案的时间复杂度是多少？
【发布时间】：2016-08-19 17:24:59
【问题描述】：

场景：

我有一个名为“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;
}

【问题讨论】：

你应该考虑当你的输入包含小于-1的负数时会发生什么
我不认为这是输入。这是找到target 的数组索引。他正在记录目标编号的第一个和最后一个索引。 -1 是数组索引的不可能值。
该代码有效吗？你测试过吗？您有正确的想法进行二分搜索以达到 O(logn)。
这是 O(logn) 假设现在您的输入数组已排序，而您的初始版本不需要。因此，根据您获取排序数组的方式，总体而言，这应该是比以前更好的解决方案。这是 O(logn)，因为每次递归调用都在处理一半的数组。
你的数组排序了吗？如果您的数组已排序，您可以通过二进制搜索轻松确定 O(logn)。

标签： java algorithm time-complexity

【解决方案1】：

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

【讨论】：