Java 该算法具有二进制搜索和while循环，其时间复杂度是多少？

我试图计算findingDup算法的运行时复杂性，因为我不确定它是O（n）还是O（logn）。我的目标是实现一个次线性算法，找出int值的重复次数。您可以假设给定的数组int[]A总是被排序的。如果您有任何其他问题，请在下面留下

public class Controller {
    
    public static void main(String[] args){
        
        int[] A = {-1, 2, 3, 5, 6, 6, 6, 9, 10};
        
        int value = 6;
        
        System.out.println(findingDup(A, value));
        
    }// end main
    
    public static int findingDup(int[] a, int x){
        
        int counter = 0;
        
        int index = binarySearch(a, x); // index = 4 
        
        int leftIndex = index - 1;      // leftIndex = 3
        int rightIndex = index + 1;     // rightIndex = 5
        
        if(index == -1){
            return 0;
        }
        else if(a[index] == x){
            counter++;
        }
        
        // checking if all numbers are dups
        if(a[0] == a[a.length - 1]){
            return a.length;
        }
        
        if(leftIndex >= 0){
            
            while(a[leftIndex] == x){
                counter++;
                leftIndex--;
                
                if(leftIndex < 0){
                    break;
                }
                
            }
            
        }
        
        if(rightIndex <= a.length - 1){
           
            while(a[rightIndex] == x){
                counter++;
                rightIndex++;
                
                if(rightIndex > a.length - 1){
                    break;
                }
                
            }
            
        }
        
        return counter;
        
    }// end method
    
    public static int binarySearch(int[] a, int x){
    
    int low = 0, high = a.length - 1;
    
    while(low <= high){
        
        int mid = (low + high) / 2;
        
        if(a[mid] < x){
            low = mid + 1;
        }
        else if(a[mid] > x){
            high = mid - 1;
        }
        else{
            return mid;
        }
    }
    
    return -1;
    
    }// End Method
    
    
}// end class

公共类控制器{
公共静态void main（字符串[]args）{
int[]A={-1,2,3,5,6,6,6,9,10}；
int值=6；
System.out.println（findingDup（A，value））；
}//端干管
公共静态int findingDup（int[]a，int x）{
int计数器=0；
int index=binarySearch（a，x）；//index=4
int leftIndex=index-1；//leftIndex=3
int rightIndex=index+1；//rightIndex=5
如果（索引==-1）{
返回0；
}
else如果（a[索引]==x）{
计数器++；
}
//检查是否所有数字都是重复的
如果（a[0]==a[a.length-1]）{
返回a.length；
}
如果（leftIndex>=0）{
while（a[leftIndex]==x）{
计数器++；
左索引--；
if（leftIndex<0）{
打破
}
}
}
如果（右索引a.长度-1）{
打破
}
}
}
返回计数器；
}//结束方法
公共静态int二进制搜索（int[]a，int x）{
int低=0，高=a。长度-1；
while（低x）{
高=中-1；
}
否则{
中途返回；
}
}
返回-1；
}//结束方法
}//末级

您的代码是O（k+logn），其中“k”是值出现在列表中的次数

如果k=O（n），则降解为O（n）

例如，在列表为[6,6,6,6,6，…]的极端情况下，您将处理所有元素

您仍然可以通过运行多个二进制搜索来解决此问题

首先运行它以查找“value”的第一个匹配项，然后再次运行它以查找大于value的第一个数字（搜索value+1）

需要修改二进制搜索算法以返回第一次出现的值，如果找不到该值，则返回更大的值

到目前为止，它发现了任何事件，不能保证是第一次也不能保证是最后一次

您的二进制搜索具有以下条件：

if (smaller) {...}
else if (larger) {...}
else {we have found it!}

所以它可以返回任何事件

您应该寻找以下索引：

a[mid - 1] < value && a[mid] >= value

a[mid-1]=value

mid-1可以小于0，因此需要首先检查该值

---

如果不是这样，我们还没有找到第一个匹配项，需要向左或向右移动索引。

请详细说明如何再次运行二进制搜索以找到不同的匹配项？我仍然不知道你会怎么做。扩大答案。