如何找到这个程序的最坏情况复杂度是多少？

Question

• V is sorted
• V.size() = N
• The function is initially called as searchNumOccurrence(V, k, 0, N-1)

Code for function:

int searchNumOccurrence(vector<int> &V, int k, int start, int end) {
    if (start > end) return 0;
    int mid = (start + end) / 2;

    if (V[mid] < k) return searchNumOccurrence(V, k, mid + 1, end);
    if (V[mid] > k) return searchNumOccurrence(V, k, start, mid - 1);

    return searchNumOccurrence(V, k, start, mid - 1) + 
            1 + searchNumOccurrence(V,k, mid + 1, end);
}

Answer 1

Ok, lets check what you do. First, you take middle index. Then you check if number is bigger or smaller V[mid] , and if its not, you will increase counter and check left and right, by moving mid position by 1 (searchNumOccurrence(V, k, start, mid - 1)) & searchNumOccurrence(V,k, mid + 1, end) .

Problem here is this moving of mid by 1. Lets say, you have this array:

2 2 2 2 2 2 2 2 2 2 2 2 2 2

This means, you will have to check each index by iterating it by 1. That is O(n) , so your algorithm is O(n) .

Now, there is a better way. Since you have sorted array, don't look for each occurrence, search for subset of that number, more precise, starting and ending index of subset of that number in given array. In that way, you basically search for 2 indexes, with this rule:

• index1 is where V[index1] = k , but if index1 > 0 then its V[index1 - 1] < k

• index2 is where V[index2] = k but if index2 < end - 1 then its V[index2 + 1] > k

Searching this two indexes are O(log_2(n)) ( O(lgn) ), and result is numberOfOccurrences = index2 - index1 + 1 .

Edit: First, search for left index. If k doesn't exist in array, return 0 for function and you don't need to go for right index (thanks @craig-young). If left index is found, then you know you will find right (exist if and only if left index exists), but search under subset [index1, end) .

Answer 2

The worst case scenario would be when the recursive function must iterate through all elements.

ie) If |V|=4 , k=1

1 1 1 1

1 1 | 1 1

1 | 1

1

The height of the tree above would be O(log_2(|V|)) and the number of elements would be O(|V|) . Hence wrt |V|, there would be at most O(|V|log_2(|V|)) recursive calls where |V| is the size of V.

It's been a while since I took algorithms, so if anybody can let me know if I got it wrong somewhere that would be great.

Answer 3

What if all the values in the array are the same ? How long does the program run then ?It might seem at the first look that the program is O(log N). However, the last case

return searchNumOccurrence(V, k, start, mid - 1) + 1 + searchNumOccurrence(V, k, mid + 1, end);

is the bottleneck step. Assuming all the values in the array are the same, we get the following relation :

T(N) = 2 * T(N/2) + constant
     = 4 * T(N/4) + constant     ( 2 * constant = another constant ) 
     = 8 * T(N/8) + constant 
     ...
     = N * T(N/N) + constant 
     = N + constant 
     = O(N)