Algorithm O（n）中的连续子数组解决方案

最近我遇到了一个问题，指出有一个整数数组，我们将得到一个通配符。我们需要查看整个数组并形成一个子数组，以便

通配符编号应为子数组的最后一个元素（即 ：{2,3,4}是有效的，如果4是通配符号码，但是{2,4,3}是无效的）

通配符编号之前的所有元素都应小于 那个（即：{2,3,4}是有效的，如果4是通配符号码，但是{5,2,4} 无效）

通配符编号不应在两个子阵列之间插入

输出应返回此类子数组的长度

示例问题： 如果数组为{4,5,6,4,3,2,4,8,2,4}，且通配符号为4，则输出应为7。（因为子数组是{4}、{4}、{3,2,4}、{2,4}）

我已经为这个问题编写了代码。但我需要知道的是，这个解决方案是否可以用O（n）时间复杂度来编写。还有一种方法可以通过单独查看问题来找到最佳的时间复杂度

代码段：

private static void solution(int[] array, int k)
    {
        int forwardCounter = 0;
        int backwardCounter = 0;
        int length = 0;

        while(forwardCounter != array.length)
        {
            if(array[forwardCounter] == k)
            {
                length++;
                backwardCounter = forwardCounter - 1;
                while(backwardCounter >= 0)
                {
                    if(backwardCounter >= 0 && array[backwardCounter--] < k)
                    {
                        length++;
                    }
                    else
                        break;
                }
            }
            forwardCounter++;
        }
        System.out.println(length);
    }

    public static void main(String[] args) 
    {
        solution(new int[]{4,5,6,4,3,2,4,8,2,4}, 4);
    }

私有静态无效解决方案（int[]数组，int k）
{
int forwardCounter=0；
int backwardCounter=0；
整数长度=0；
while（forwardCounter！=array.length）
{
if（数组[forwardCounter]==k）
{
长度++；
backwardCounter=forwardCounter-1；
而（反向计数器>=0）
{
if（backardcounter>=0&&array[backardcounter--]

您的解决方案是线性的，但在最坏的情况下，您的数组将被遍历两次。当
-数组按升序排序
-通配符是数组的最后一个（即最大）元素

---

您的解决方案可以进行修改，以防止向后遍历，并仅使用向前遍历

谢谢mangusta。但是，有没有一种方法可以通过单独查看问题陈述来找到特定问题的最佳复杂度？这取决于问题。例如，比较排序已被证明具有复杂性

omega（nlogn）

，即无法在较短时间内解决它。我认为大多数问题都可以用最少的时间来解决（仅给出声明）