Skip to content
Related Articles

Related Articles

Ceiling in a sorted array
  • Difficulty Level : Easy
  • Last Updated : 07 Apr, 2021

Given a sorted array and a value x, the ceiling of x is the smallest element in array greater than or equal to x, and the floor is the greatest element smaller than or equal to x. Assume than the array is sorted in non-decreasing order. Write efficient functions to find 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 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: 
1) If x is smaller than or equal to the first element in array then return 0(index of first element) 
2) Else Linearly search for an index i such that x lies between arr[i] and arr[i+1]. 
3) If we do not find an index i in step 2, then return -1 
 

C++




// 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

C




#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;
}

Java




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]);
    
}

Python3




# 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 = 3
index = 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#




// C# program to find celing
// 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 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




<?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.
?>

Javascript




<script>
 
/* Function to get index of ceiling of
x 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>

Output : 

ceiling of 3 is 8

Time Complexity : O(n)
Method 2 (Binary Search) 
Instead of using linear search, binary search is used here to find out the index. Binary search reduces time complexity to O(Logn). 
 

C++




#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 Code
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)
        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

C




#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;
}

Java




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 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 */
    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]);
    
}

Python3




# 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 functions */
arr = [1, 2, 8, 10, 10, 12, 19]
n = len(arr)
x = 20
index = 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#




// C# program to find celing
// 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
// 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.
?>

Javascript




<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 Code
let 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>

Output : 
 



Ceiling of 20 doesn't exist in array 

Time Complexity: O(Logn)
 

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, or find better ways to solve the same problem, or want to share code for floor implementation.
 

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

My Personal Notes arrow_drop_up
Recommended Articles
Page :