数组函数的时间复杂度

Question

I wrote a function to find the position where the target value should be inserted in the given array. We assume the array has distinct values and is sorted in ascending order. My solution must be in O(log N) time complexity

public static int FindPosition(int[] A, int target) {


    int a = A.length / 2;
    System.out.println(a);
    int count = a;
    for (int i = a; i < A.length && A[i] < target; i++) {
        count++;
    }
    for (int i = a; i > A.length && A[i] > target; i--) {
        count++;
    }
    return count;
}

Does this code have complexity of O(log N)?

Answer 1

Short answer

No.

Longer answer

With increments of 1 in your indices, you cannot expect to have a better solution than O(n) .

If your algorithm works at all (I don't think it does), it looks like it would need O(n) steps.

Also, you say you assume that the array is sorted, but you sort it anyway. So your code is O(n*log(n)) .

What's more, trying to sort an already sorted array is the worst case for some sorting algorithms : it might even be O(n**2) .

You're looking for a binary search .

Answer 2

No it isn't nlogn

public static int FindPosition(int[] A, int target){
/*
Time taken to sort these elements would depend on how
sort function is implemented in java.  Arrays.sort has average 
time complexity of Ω(n log n), and worst case of O(n^2)
*/
Arrays.sort(A);


/*Time taken to run this loop = O(length of A) or O(N) 
where N = arraylength
*/

for(int i=a;i<A.length&&A[i]<target;i++){
    count++;
}
/*Time taken to run this loop = O(length of A) or O(N) 
where N = arraylength
*/
for(int i=a;i>A.length&&A[i]>target;i--){
    count++;
}
return count;
}

Now time complexity would be represented by the longest of above three, since assignments and all are done in constant time.

Thus making your complexity O(n^2) in worst case.