Ceiling in a sorted array

29 Jun, 2022
Given a sorted array and a value x, the ceiling of x is the smallest element in an array greater than or equal to x, and the floor is the greatest element smaller than or equal to x. Assume that the array is sorted in non-decreasing order. Write efficient functions to find the floor and ceiling of x. Examples : 
For example, let the input array be {1, 2, 8, 10, 10, 12, 19}
For x = 0:    floor doesn't exist in array,  ceil  = 1
For x = 1:    floor  = 1,  ceil  = 1
For x = 5:    floor  = 2,  ceil  = 8
For x = 20:   floor  = 19,  ceil doesn't exist in array
In the below methods, we have implemented only ceiling search functions. Floor search can be implemented in the same way.
Method 1 (Linear Search) Algorithm to search ceiling of x: 
If x is smaller than or equal to the first element in the array then return 0(index of the first element).Else linearly search for an index i such that x lies between arr[i] and arr[i+1]. If we do not find an index i in step 2, then return -1. 
If x is smaller than or equal to the first element in the array then return 0(index of the first element).
Else linearly search for an index i such that x lies between arr[i] and arr[i+1]. 
If we do not find an index i in step 2, then return -1. 
Below is the implementation of the above approach:
C++
C
Java
Python3
C#
PHP
Javascript
// C++ implementation of above approach#include <bits/stdc++.h>using namespace std; /* Function to get index of ceiling of x in arr[low..high] */int ceilSearch(int arr[], int low, int high, int x){         int i;         /* If x is smaller than or equal to first element,        then return the first element */    if(x <= arr[low])        return low;         /* Otherwise, linearly search for ceil value */    for(i = low; i < high; i++)    {        if(arr[i] == x)        return i;             /* if x lies between arr[i] and arr[i+1] including        arr[i+1], then return arr[i+1] */        if(arr[i] < x && arr[i+1] >= x)        return i+1;    }             /* If we reach here then x is greater than the last element        of the array, return -1 in this case */    return -1;}  /* Driver code*/int main(){    int arr[] = {1, 2, 8, 10, 10, 12, 19};    int n = sizeof(arr)/sizeof(arr[0]);    int x = 3;    int index = ceilSearch(arr, 0, n-1, x);    if(index == -1)        cout << "Ceiling of " << x << " doesn't exist in array ";    else        cout << "ceiling of " << x << " is " << arr[index];         return 0;} // This is code is contributed by rathbhupendra
#include<stdio.h> /* Function to get index of ceiling of x in arr[low..high] */int ceilSearch(int arr[], int low, int high, int x){  int i;      /* If x is smaller than or equal to first element,    then return the first element */  if(x <= arr[low])    return low;    /* Otherwise, linearly search for ceil value */  for(i = low; i < high; i++)  {    if(arr[i] == x)      return i;     /* if x lies between arr[i] and arr[i+1] including       arr[i+1], then return arr[i+1] */    if(arr[i] < x && arr[i+1] >= x)       return i+1;  }           /* If we reach here then x is greater than the last element    of the array,  return -1 in this case */  return -1;}  /* Driver program to check above functions */int main(){   int arr[] = {1, 2, 8, 10, 10, 12, 19};   int n = sizeof(arr)/sizeof(arr[0]);   int x = 3;   int index = ceilSearch(arr, 0, n-1, x);   if(index == -1)     printf("Ceiling of %d doesn't exist in array ", x);   else     printf("ceiling of %d is %d", x, arr[index]);   getchar();   return 0;}
class Main{    /* Function to get index of ceiling       of x in arr[low..high] */    static int ceilSearch(int arr[], int low, int high, int x)    {      int i;               /* If x is smaller than or equal to first         element,then return the first element */      if(x <= arr[low])        return low;             /* Otherwise, linearly search for ceil value */      for(i = low; i < high; i++)      {        if(arr[i] == x)          return i;              /* if x lies between arr[i] and arr[i+1]        including arr[i+1], then return arr[i+1] */        if(arr[i] < x && arr[i+1] >= x)           return i+1;      }                    /* If we reach here then x is greater than the      last element of the array,  return -1 in this case */      return -1;    }                /* Driver program to check above functions */    public static void main (String[] args)    {       int arr[] = {1, 2, 8, 10, 10, 12, 19};       int n = arr.length;       int x = 3;       int index = ceilSearch(arr, 0, n-1, x);       if(index == -1)         System.out.println("Ceiling of "+x+" doesn't exist in array");       else         System.out.println("ceiling of "+x+" is "+arr[index]);    } }
# Function to get index of ceiling of x in arr[low..high] */def ceilSearch(arr, low, high, x):     # If x is smaller than or equal to first element,    # then return the first element */    if x <= arr[low]:        return low     # Otherwise, linearly search for ceil value */    i = low    for i in range(high):        if arr[i] == x:            return i         # if x lies between arr[i] and arr[i+1] including        # arr[i+1], then return arr[i+1] */        if arr[i] < x and arr[i+1] >= x:            return i+1             # If we reach here then x is greater than the last element    # of the array,  return -1 in this case */    return -1 # Driver program to check above functions */arr = [1, 2, 8, 10, 10, 12, 19]n = len(arr)x = 3index = ceilSearch(arr, 0, n-1, x); if index == -1:    print ("Ceiling of %d doesn't exist in array "% x)else:    print ("ceiling of %d is %d"%(x, arr[index])) # This code is contributed by Shreyanshi Arun
// C# program to find ceiling// in a sorted arrayusing System; class GFG {         // Function to get index of ceiling    // of x in arr[low..high]    static int ceilSearch(int[] arr, int low,                           int high, int x)    {        int i;         // If x is smaller than or equal        // to first element, then return        // the first element        if (x <= arr[low])            return low;         // Otherwise, linearly search        // for ceil value        for (i = low; i < high; i++) {            if (arr[i] == x)                return i;             /* if x lies between arr[i] and            arr[i+1] including arr[i+1],            then return arr[i+1] */            if (arr[i] < x && arr[i + 1] >= x)                return i + 1;        }         /* If we reach here then x is        greater than the last element        of the array, return -1 in        this case */        return -1;    }     // Driver code    public static void Main()    {        int[] arr = { 1, 2, 8, 10, 10, 12, 19 };        int n = arr.Length;        int x = 3;        int index = ceilSearch(arr, 0, n - 1, x);                 if (index == -1)            Console.Write("Ceiling of " + x +                     " doesn't exist in array");        else            Console.Write("ceiling of " + x +                         " is " + arr[index]);    }} // This code is contributed by Sam007.
<?php// Function to get index of// ceiling of x in arr[low..high]function ceilSearch($arr, $low, $high, $x){     // If x is smaller than or equal    // to first element, then return    // the first element    if($x <= $arr[$low])        return $low;         // Otherwise, linearly search    // for ceil value    for($i = $low; $i < $high; $i++)    {        if($arr[$i] == $x)            return $i;             // if x lies between arr[i] and        // arr[i+1] including arr[i+1],        // then return arr[i+1]        if($arr[$i] < $x &&           $arr[$i + 1] >= $x)            return $i + 1;    }             // If we reach here then x is greater    // than the last element of the array,    // return -1 in this case    return -1;} // Driver Code$arr = array(1, 2, 8, 10, 10, 12, 19);$n = sizeof($arr);$x = 3;$index = ceilSearch($arr, 0, $n - 1, $x);if($index == -1)    echo("Ceiling of " . $x .         " doesn't exist in array ");else    echo("ceiling of " . $x . " is " .                        $arr[$index]); // This code is contributed by Ajit.?>
<script> /* Function to get index of ceiling ofx in arr[low..high] */function ceilSearch(arr, low, high, x){         let i;         /* If x is smaller than or equal to first element,        then return the first element */    if(x <= arr[low])        return low;         /* Otherwise, linearly search for ceil value */    for(i = low; i < high; i++)    {        if(arr[i] == x)        return i;             /* if x lies between arr[i] and arr[i+1] including        arr[i+1], then return arr[i+1] */        if(arr[i] < x && arr[i+1] >= x)        return i+1;    }             /* If we reach here then    x is greater than the last element        of the array, return -1 in this case */    return -1;}     // driver code     let arr = [1, 2, 8, 10, 10, 12, 19];    let n = arr.length;    let x = 3;    let index = ceilSearch(arr, 0, n-1, x);    if(index == -1)        document.write("Ceiling of " + x + " doesn't exist in array ");    else        document.write ("ceiling of " + x + " is " + arr[index]);   </script>
ceiling of 3 is 8
Time Complexity: O(n), Auxiliary Space: O(1)
Method 2 (Binary Search) 
Instead of using linear search, binary search is used here to find out the index. Binary search reduces the time complexity to O(Logn). 
C++
C
Java
Python3
C#
PHP
Javascript
#include <bits/stdc++.h>using namespace std; /* Function to get index of   ceiling of x in arr[low..high]*/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[low...mid-1] */    else {        if (mid - 1 >= low && x > arr[mid - 1])            return mid;        else            return ceilSearch(arr, low, mid - 1, x);    }} // Driver Codeint main(){    int arr[] = { 1, 2, 8, 10, 10, 12, 19 };    int n = sizeof(arr) / sizeof(arr[0]);    int x = 20;    int index = ceilSearch(arr, 0, n - 1, x);    if (index == -1)        cout << "Ceiling of " << x             << " doesn't exist in array ";    else        cout << "ceiling of " << x << " is " << arr[index];     return 0;} // This code is contributed by rathbhupendra
#include <stdio.h> /* Function to get index of ceiling of x in arr[low..high]*/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[low...mid-1]     */    else {        if (mid - 1 >= low && x > arr[mid - 1])            return mid;        else            return ceilSearch(arr, low, mid - 1, x);    }} /* Driver program to check above functions */int main(){    int arr[] = { 1, 2, 8, 10, 10, 12, 19 };    int n = sizeof(arr) / sizeof(arr[0]);    int x = 20;    int index = ceilSearch(arr, 0, n - 1, x);    if (index == -1)        printf("Ceiling of %d doesn't exist in array ", x);    else        printf("ceiling of %d is %d", x, arr[index]);    getchar();    return 0;}
class Main {    /* Function to get index of       ceiling of x in arr[low..high]*/    static int ceilSearch(int arr[], int low, int high,                          int x)    {        // base condition if length of arr == 0 then return        // -1        if (high == 0) {            return -1;        }        /* this while loop function will run until condition         not break once condition break loop will return         start and ans is low which will be next smallest         greater than target which is ceiling*/        while (low <= high) {            int mid                = low + (high - low) / 2; // calculate mid             if (x == arr[mid]) {                return mid;            }            if (x < arr[mid]) {                high = mid - 1;            }             else {                low = mid + 1;            }        }        return low;    }    /* step 1 : { low = 1, 2, 8, 10= mid, 10, 12, 19= high};              if( x < mid) yes set high = mid -1;    step 2 : { low = 1, 2 = mid, 8 = high, 10, 10, 12, 19};              if( x < mid) no set low = mid + 1;    step 3 : {1, 2, 8 = high,low,low,  10, 10, 12, 19};               if( x == mid ) yes return mid               if(x < mid ) no low = mid + 1    step 4  : {1, 2, 8 = high,mid, 10 = low, 10, 12, 19};              check while(low < = high)               condition break and return low which will    next greater of target */     /* Driver program to check above functions */    public static void main(String[] args)    {        int arr[] = { 1, 2, 8, 10, 10, 12, 19 };        int n = arr.length;        int x = 8;        int index = ceilSearch(arr, 0, n - 1, x);        if (index == -1)            System.out.println("Ceiling of " + x                               + " doesn't exist in array");        else            System.out.println("ceiling of " + x + " is "                               + arr[index]);    }}
# Function to get index of ceiling of x in arr[low..high]*/def ceilSearch(arr, low, high, x):     # 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] */    elif arr[mid] < x:        if mid + 1 <= high and 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[low...mid-1] */      else:        if mid - 1 >= low and x > arr[mid-1]:            return mid        else:            return ceilSearch(arr, low, mid - 1, x)  # Driver program to check above functionsarr = [1, 2, 8, 10, 10, 12, 19]n = len(arr)x = 20index = ceilSearch(arr, 0, n-1, x); if index == -1:    print ("Ceiling of %d doesn't exist in array "% x)else:    print ("ceiling of %d is %d"%(x, arr[index])) # This code is contributed by Shreyanshi Arun
// C# program to find ceiling// in a sorted array using System; class GFG {     // Function to get index of ceiling    // of x in arr[low..high]    static 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[low...mid-1]        else {            if (mid - 1 >= low && x > arr[mid - 1])                return mid;            else                return ceilSearch(arr, low, mid - 1, x);        }    }     // Driver code    public static void Main()    {        int[] arr = { 1, 2, 8, 10, 10, 12, 19 };        int n = arr.Length;        int x = 8;        int index = ceilSearch(arr, 0, n - 1, x);        if (index == -1)            Console.Write("Ceiling of " + x                          + " doesn't exist in array");        else            Console.Write("ceiling of " + x + " is "                          + arr[index]);    }} // This code is contributed by Sam007.
<?php// PHP Program for Ceiling in// a sorted array // Function to get index of ceiling// of x in arr[low..high]function ceilSearch($arr, $low,                    $high, $x){    $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] */    // low + (high - low)/2    $mid = ($low + $high)/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[low....mid-1] */    else    {        if($mid - 1 >= $low &&           $x > $arr[$mid - 1])            return $mid;        else         return ceilSearch($arr, $low,                           $mid - 1, $x);    }} // Driver Code$arr = array(1, 2, 8, 10, 10, 12, 19);$n = sizeof($arr);$x = 20;$index = ceilSearch($arr, 0, $n - 1, $x);if($index == -1)    echo("Ceiling of $x doesn't exist in array ");else    echo("ceiling of $x is");    echo(isset($arr[$index])); // This code is contributed by nitin mittal.?>
<script>// Javascript Program for Ceiling in // a sorted array   // Function to get index of ceiling// of x in arr[low..high]function ceilSearch(arr, low, high, x){    let 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] */    // low + (high - low)/2    mid = (low + high)/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[low....mid-1] */    else    {        if(mid - 1 >= low && x > arr[mid - 1])          return mid;        else         return ceilSearch(arr, low, mid - 1, x);    }}   // Driver Codelet arr = [1, 2, 8, 10, 10, 12, 19];let n = arr.length;let x = 20;let index = ceilSearch(arr, 0, n - 1, x); if(index == -1){    document.write(`Ceiling of ${x} doesn't exist in array `);}else{    document.write(`ceiling of ${x} is ${arr[index]}`); }   // This code is contributed by _saurabh_jaiswal. </script>
Ceiling of 20 doesn't exist in array 
Time Complexity: O(log(n)), Auxiliary Space: O(1)
Another Implementation of Method 2 :
As like previous method here also binary search is being used but the code logic is different instead of lots of if else check i will simply return and lets understand through below steps :
Step 1 : { low->1, 2, 8, 10<-mid, 10, 12, 19<-high};
if( x < mid) yes set high = mid -1;
Step 2 : { low ->1, 2 <-mid, 8 <-high, 10, 10, 12, 19};
if( x < mid) no set low = mid + 1;
Step 3 : {1, 2, 8<-high,low,mid,  10, 10, 12, 19};
if( x == mid ) yes return mid  
if(x < mid ) no low = mid + 1
Step 4  : {1, 2, 8<-high,mid, 10<-low, 10, 12, 19};
check while(low =<  high)
condition break and return low which is my ceiling of  target.
C++
Java
C#
Javascript
Python3
#include <bits/stdc++.h>using namespace std; /* Function to get index of       ceiling of x in arr[low..high]*/int ceilSearch(int arr[], int low, int high, int x){   // base condition if length of arr == 0 then return -1  if (x == 0)  {    return -1;  }  int mid;   /* this while loop function will run until  condition not break once condition break       loop will return start and ans is low       which will be next smallest greater than target       which is ceiling*/  while (low <= high)  {    mid = low + (high - low) / 2;    if (arr[mid] == x)    {      return mid;    }    else if (x < arr[mid])    {       high = mid - 1;    }    else    {       low = mid + 1;    }   }  return low;} /* step 1 : { low = 1, 2, 8, 10= mid, 10, 12, 19= high};                if( x < mid) yes set high = mid -1;      step 2 : { low = 1, 2 = mid, 8 = high, 10, 10, 12, 19};                if( x < mid) no set low = mid + 1;      step 3 : {1, 2, 8 = high,low,low,  10, 10, 12, 19};                 if( x == mid ) yes return mid                 if(x < mid ) no low = mid + 1      step 4  : {1, 2, 8 = high,mid, 10 = low, 10, 12, 19};                check while(low < = high)                 condition break and return low which will next greater of target */ /* Driver program to check above functions */int main(){  int arr[] = {1, 2, 8, 10, 10, 12, 19};  int n = sizeof(arr) / sizeof(arr[0]);  int x = 8;  int index = ceilSearch(arr, 0, n - 1, x);  if (index == -1)  {    cout << "Ceiling of " << x << " does not exist in an array";  }  else  {    cout << "Ceiling of " << x << " is " << arr[index];  }  return 0;}
class Main {    /* Function to get index of       ceiling of x in arr[low..high]*/    static int ceilSearch(int arr[], int low, int high,                          int x)    {        // base condition if length of arr == 0 then return        // -1        if (x == 0) {            return -1;        }        /* this while loop function will run until condition         not break once condition break loop will return         start and ans is low which will be next smallest         greater than target which is ceiling*/        while (low <= high) {            int mid                = low + (high - low) / 2; // calculate mid             if (x == arr[mid]) {                return mid;            }            if (x < arr[mid]) {                high = mid - 1;            }             else {                low = mid + 1;            }        }        return low;    }    /* step 1 : { low = 1, 2, 8, 10= mid, 10, 12, 19= high};              if( x < mid) yes set high = mid -1;    step 2 : { low = 1, 2 = mid, 8 = high, 10, 10, 12, 19};              if( x < mid) no set low = mid + 1;    step 3 : {1, 2, 8 = high,low,low,  10, 10, 12, 19};               if( x == mid ) yes return mid               if(x < mid ) no low = mid + 1    step 4  : {1, 2, 8 = high,mid, 10 = low, 10, 12, 19};              check while(low < = high)               condition break and return low which will    next greater of target */     /* Driver program to check above functions */    public static void main(String[] args)    {        int arr[] = { 1, 2, 8, 10, 10, 12, 19 };        int n = arr.length;        int x = 8;        int index = ceilSearch(arr, 0, n - 1, x);        if (index == -1)            System.out.println("Ceiling of " + x                               + " doesn't exist in array");        else            System.out.println("ceiling of " + x + " is "                               + arr[index]);    }}
// C# program for the above approach using System;class GFG{  /* Function to get index of       ceiling of x in arr[low..high]*/  static int ceilSearch(int[] arr, int low, int high, int x)  {    // base condition if length of arr == 0 then return -1    if (x == 0)    {      return -1;    }    /* this while loop function will run until condition not break once condition break         loop will return start and ans is low which will be next smallest greater than target         which is ceiling*/    while (low <= high)    {      int mid = low + (high - low) / 2;//calculate mid       if (x == arr[mid])      {        return mid;      }      if (x < arr[mid])      {        high = mid - 1;      }       else      {        low = mid + 1;      }    }    return low;    /* step 1 : { low = 1, 2, 8, 10= mid, 10, 12, 19= high};                  if( x < mid) yes set high = mid -1;        step 2 : { low = 1, 2 = mid, 8 = high, 10, 10, 12, 19};                  if( x < mid) no set low = mid + 1;        step 3 : {1, 2, 8 = high,low,low,  10, 10, 12, 19};                   if( x == mid ) yes return mid                   if(x < mid ) no low = mid + 1        step 4  : {1, 2, 8 = high,mid, 10 = low, 10, 12, 19};                  check while(low < = high)                   condition break and return low which will next greater of target */   }     /* Driver program to check above functions */  public static void Main()  {    int[] arr = { 1, 2, 8, 10, 10, 12, 19 };    int n = arr.Length;    int x = 8;    int index = ceilSearch(arr, 0, n - 1, x);    if (index == -1)      Console.WriteLine("Ceiling of " + x + " doesn't exist in array");    else      Console.WriteLine("ceiling of " + x + " is " + arr[index]);  }}
//JS program to implement the approach /* Function to get index of       ceiling of x in arr[low..high]*/function ceilSearch(arr, low, high, x){   // base condition if length of arr == 0 then return -1  if (x == 0)  {    return -1;  }  var mid;   /* this while loop function will run until  condition not break once condition break       loop will return start and ans is low       which will be next smallest greater than target       which is ceiling*/  while (low <= high)  {    mid = low + (high - low) / 2;    if (arr[mid] == x)    {      return mid;    }    else if (x < arr[mid])    {       high = mid - 1;    }    else    {       low = mid + 1;    }   }  return low;} /* step 1 : { low = 1, 2, 8, 10= mid, 10, 12, 19= high};                if( x < mid) yes set high = mid -1;      step 2 : { low = 1, 2 = mid, 8 = high, 10, 10, 12, 19};                if( x < mid) no set low = mid + 1;      step 3 : {1, 2, 8 = high,low,low,  10, 10, 12, 19};                 if( x == mid ) yes return mid                 if(x < mid ) no low = mid + 1      step 4  : {1, 2, 8 = high,mid, 10 = low, 10, 12, 19};                check while(low < = high)                 condition break and return low which will next greater of target */ /* Driver program to check above functions */var arr = [1, 2, 8, 10, 10, 12, 19];var n = arr.length;var x = 8;var index = ceilSearch(arr, 0, n - 1, x);  if (index == -1)  {    console.log("Ceiling of " + x + " does not exist in an array");  }  else  {    console.log("Ceiling of " + x + " is " + arr[index]);  }
# Function to get index of ceiling of x in arr[low..high]def ceilSearch(arr, low, high, x):   # base condition if length of arr == 0 then return -1    if (x == 0):        return -1     """this while loop function will run until  condition not break once condition break       loop will return start and ans is low       which will be next smallest greater than target       which is ceiling"""    while (low <= high):        mid = low + (high - low) / 2        mid = int(mid)        if (arr[mid] == x):            return mid        elif (x < arr[mid]):            high = mid - 1        else:            low = mid + 1     return low  """ step 1 : { low = 1, 2, 8, 10= mid, 10, 12, 19= high};                if( x < mid) yes set high = mid -1;      step 2 : { low = 1, 2 = mid, 8 = high, 10, 10, 12, 19};                if( x < mid) no set low = mid + 1;      step 3 : {1, 2, 8 = high,low,low,  10, 10, 12, 19};                 if( x == mid ) yes return mid                 if(x < mid ) no low = mid + 1      step 4  : {1, 2, 8 = high,mid, 10 = low, 10, 12, 19};                check while(low < = high)                 condition break and return low which will next greater of target """ # Driver program to check above functionsarr = [1, 2, 8, 10, 10, 12, 19]n = len(arr)x = 8index = ceilSearch(arr, 0, n - 1, x)if (index == -1):    print("Ceiling of", x, "does not exist in an array")else:    print("Ceiling of", x, "is", arr[index])
Ceiling of 8 is 8
Time Complexity: O(log(n)), where n is the length of the given array, Auxiliary Space: O(1)
https://www.youtube.com/watch?v=Nzm9emAkSCM
Related Articles: 
Floor in a Sorted Array Find floor and ceil in an unsorted array
Please write comments if you find any of the above codes/algorithms incorrect, find better ways to solve the same problem, or want to share code for floor implementation.
jit_t
nitin mittal
rathbhupendra
MukulSamrat
_saurabh_jaiswal
jana_sayantan
nnr223442
surindertarika1234
devendrasalunke
sagartomar9927
sumitgumber28
simmytarika5
surinderdawra388
simranarora5sos
chandramauliguptach
shaheeneallamaiqbal
phasing17
susobhanakhuli
dvrv369
Binary Search
Arrays
Searching
Arrays
Searching
Binary Search
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Arrays in Java
Write a program to reverse an array or string
Maximum and minimum of an array using minimum number of comparisons
Top 50 Array Coding Problems for Interviews
Largest Sum Contiguous Subarray
Binary Search
Maximum and minimum of an array using minimum number of comparisons
Linear Search
Search an element in a sorted and rotated array
Find the Missing Number