Question

Given an array, such as [7,8,9,0,1,2,3,4,5,6], is it possible to determine the index around which a rotation has occurred faster than O(n)?

With O(n), simply iterate through all the elements and mark the first decreasing element as the index.

A possibly better solution would be to iterate from both ends towards the middle, but this still has a worst case of O(n).

Answer 1

(EDIT: The below assumes that elements are distinct. If they aren’t distinct, I don’t think there’s anything better than just scanning the array.)

You can binary search it. I won’t post any code, but here’s the general idea: (I’ll assume that a >= b for the rest of this. If a < b, then we know it’s still in its sorted order)

Take the first element, call it a, the last element b, and the middle element, calling it c.

If a < c, then you know that the pivot is between c and b, and you can recurse (with c and b as your new ends). If a > c, then you know that the pivot is somewhere between the two, and recurse in that half (with a and c as ends) instead.

ADDENDUM: To extend to cases with repeats, if we have a = c > b then we recurse with c and b as our ends, while if a = c = b, we scan from a to c to see if there is some element d such that it differs. If it doesn’t exist, then all of the numbers between a and c are equal, and thus we recurse with c and b as our ends. If it does, there are two scenarios:

a > d < b: Here, d is then the smallest element since we scanned from the left, and we’re done.
a < d > b: Here, we know the answer is somewhere between d and b, and so we recurse with those as our ends.

In the best case scenario, we never have to use the equality case, giving us O(log n). Worst case, those scans encompass almost all of the array, giving us O(n).