Open In App

# Algorithms | Searching | Question 3

Given a sorted array of integers, what can be the minimum worst-case time complexity to find ceiling of a number x in given array? The ceiling of an element x is the smallest element present in array which is greater than or equal to x. Ceiling is not present if x is greater than the maximum element present in array. For example, if the given array is {12, 67, 90, 100, 300, 399} and x = 95, then the output should be 100.

(A)

O(loglogn)

(B)

O(n)

(C)

O(log(n))

(D)

O(log(n) * log(n))

Explanation:

We modify the standard binary search to find the ceiling. The time complexity T(n) can be written as T(n) <= T(n/2) + O(1) Solution of the above recurrence can be obtained by Master Method. It falls in case 2 of the Master Method. The solution is O(Logn).

```int ceilSearch(int arr[], int low, int high, int x)
{
int mid;

/* If x is smaller than or equal to the first element,
then return the first element */
if (x <= arr[low])
return low;

/* If x is greater than the last element, then return -1
*/
if (x > arr[high])
return -1;

/* get the index of middle element of arr[low..high]*/
mid = (low + high) / 2; /* low + (high - low)/2 */

/* If x is same as middle element, then return mid */
if (arr[mid] == x)
return mid;

/* If x is greater than arr[mid], then either arr[mid +
1] is ceiling of x or ceiling lies in
arr[mid+1...high] */
else if (arr[mid] < x) {
if (mid + 1 <= high && x <= arr[mid + 1])
return mid + 1;
else
return ceilSearch(arr, mid + 1, high, x);
}

/* If x is smaller than arr[mid], then either arr[mid]
is ceiling of x or ceiling lies in arr[mid-1...high]
*/
else {
if (mid - 1 >= low && x > arr[mid - 1])
return mid;
else
return ceilSearch(arr, low, mid - 1, x);
}
}```

Hence Option(C) is the correct answer.

Quiz of this Question
Please comment below if you find anything wrong in the above post