Find floor and ceil in an unsorted array

Given an unsorted array arr[] and an element x, find floor and ceiling of x in arr[0..n-1].

Floor of x is the largest element which is smaller than or equal to x. Floor of x doesn’t exist if x is smaller than smallest element of arr[].

Ceil of x is the smallest element which is greater than or equal to x. Ceil of x doesn’t exist if x is greater than greates element of arr[].



Examples:

Input : arr[] = {5, 6, 8, 9, 6, 5, 5, 6}      
        x = 7
Output : Floor = 6
         Ceiling = 8

Input : arr[] = {5, 6, 8, 9, 6, 5, 5, 6}      
        x = 6
Output : Floor = 6
         Ceiling = 6

Input : arr[] = {5, 6, 8, 9, 6, 5, 5, 6}      
        x = 10
Output : Floor = 9
         Ceiling doesn't exist.

Method 1 (Use Sorting)
1) Sort input array.
2) Use binary search to find floor and ceiling of x. Refer this and this for implementation of floor and ceiling in a sorted array.

Time Complexity : O(n log n)
Auxiliary Space : O(1)

This solution is works well if there are multiple queries of floor and ceiling on a static array. We can sort the array once and answer the queries in O(Log n) time.

 
Method 2 (Use Linear Search
The idea is to traverse array and keep track of two distances with respect to x.
1) Minimum distance of element greater than or equal to x.
2) Minimum distance of element smaller than or equal to x.
Finally print elements with minimum distances.

C/C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ program to find floor and ceiling in an
// unsorted array.
#include<bits/stdc++.h>
using namespace std;
  
// Function to floor and ceiling of x in arr[]
void floorAndCeil(int arr[], int n, int x)
{
    // Indexes of floor and ceiling
    int fInd, cInd;
  
    // Distances of current floor and ceiling
    int fDist = INT_MAX, cDist = INT_MAX;
  
    for (int i=0; i<n; i++)
    {
        // If current element is closer than
        // previous ceiling.
        if (arr[i] >= x && cDist > (arr[i] - x))
        {
           cInd = i;
           cDist = arr[i] - x;
        }
  
        // If current element is closer than
        // previous floor.
        if (arr[i] <= x && fDist > (x - arr[i]))
        {
           fInd = i;
           fDist = x - arr[i];
        }
    }
  
    if (fDist == INT_MAX)
      cout << "Floor doesn't exist " << endl;
    else
      cout << "Floor is "  << arr[fInd] << endl;
  
    if (cDist == INT_MAX)
      cout << "Ceil doesn't exist " << endl;
    else
      cout << "Ceil is "  << arr[cInd] << endl;
}
  
// Driver code
int main()
{
    int arr[] = {5, 6, 8, 9, 6, 5, 5, 6};
    int n = sizeof(arr)/sizeof(int);
    int x = 7;
    floorAndCeil(arr, n, x);
    return 0;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java program to find floor and ceiling in an
// unsorted array.
import java.io.*;
  
class GFG 
{
     // Function to floor and ceiling of x in arr[]
    public static void floorAndCeil(int arr[], int x)
    {
        int n = arr.length;
          
        // Indexes of floor and ceiling
        int fInd = -1, cInd = -1;
   
        // Distances of current floor and ceiling
        int fDist = Integer.MAX_VALUE, cDist = Integer.MAX_VALUE;
   
        for (int i = 0; i < n; i++)
        {
            // If current element is closer than
            // previous ceiling.
            if (arr[i] >= x && cDist > (arr[i] - x))
            {
                cInd = i;
                cDist = arr[i] - x;
            }
   
            // If current element is closer than
            // previous floor.
            if (arr[i] <= x && fDist > (x - arr[i]))
            {
                fInd = i;
                fDist = x - arr[i];
            }
        }
   
        if(fDist == Integer.MAX_VALUE)
            System.out.println("Floor doesn't exist " );
        else
            System.out.println("Floor is " +  arr[fInd]);
   
        if(cDist == Integer.MAX_VALUE)
            System.out.println("Ceil doesn't exist ");
        else
            System.out.println("Ceil is  " + arr[cInd]);
    }
      
    public static void main (String[] args) 
    {
        int arr[] = {5, 6, 8, 9, 6, 5, 5, 6};
        int x = 7;
        floorAndCeil(arr, x);
    }
}

chevron_right


Python 3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python 3 program to find 
# floor and ceiling in an
# unsorted array.
  
import sys
  
# Function to floor and
# ceiling of x in arr[]
def floorAndCeil(arr, n, x):
  
    # Distances of current
    # floor and ceiling
    fDist = sys.maxsize
    cDist = sys.maxsize
  
    for i in range(n):
      
        # If current element is closer 
        # than previous ceiling.
        if (arr[i] >= x and 
            cDist > (arr[i] - x)):
          
            cInd = i
            cDist = arr[i] - x
  
        # If current element is closer 
        # than previous floor.
        if (arr[i] <= x and fDist > (x - arr[i])):
          
            fInd = i
            fDist = x - arr[i]
  
    if (fDist == sys.maxsize):
        print("Floor doesn't exist ")
    else:
        print("Floor is " + str(arr[fInd])) 
  
    if (cDist == sys.maxsize):
        print( "Ceil doesn't exist ")
    else:
        print("Ceil is " + str(arr[cInd]))
  
# Driver code
if __name__ == "__main__":
    arr = [5, 6, 8, 9, 6, 5, 5, 6]
    n = len(arr)
    x = 7
    floorAndCeil(arr, n, x)
  
# This code is contributed 
# by ChitraNayal

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# program to find floor and ceiling in an
// unsorted array.
using System;
  
class GFG {
      
    // Function to floor and ceiling of x in arr[]
    public static void floorAndCeil(int []arr, int x)
    {
        int n = arr.Length;
          
        // Indexes of floor and ceiling
        int fInd = -1, cInd = -1;
  
        // Distances of current floor and ceiling
        int fDist = int.MaxValue,
            cDist =int.MaxValue;
              
        for (int i = 0; i < n; i++)
        {
              
            // If current element is closer than
            // previous ceiling.
            if (arr[i] >= x && cDist > (arr[i] - x))
            {
                cInd = i;
                cDist = arr[i] - x;
            }
  
            // If current element is closer than
            // previous floor.
            if (arr[i] <= x && fDist > (x - arr[i]))
            {
                fInd = i;
                fDist = x - arr[i];
            }
        }
  
        if(fDist == int.MaxValue)
            Console.Write("Floor doesn't exist " );
        else
            Console.WriteLine("Floor is " + arr[fInd]);
  
        if(cDist == int.MaxValue)
        Console.Write("Ceil doesn't exist ");
        else
            Console.Write("Ceil is " + arr[cInd]);
    }
      
    // Driver code
    public static void Main () 
    {
        int []arr = {5, 6, 8, 9, 6, 5, 5, 6};
        int x = 7;
          
        floorAndCeil(arr, x);
    }
}
  
// This code is contributed by nitin mittal.

chevron_right


PHP

filter_none

edit
close

play_arrow

link
brightness_4
code

<?php
// PHP program to find 
// floor and ceiling in 
// an unsorted array.
  
// Function to floor and 
// ceiling of x in arr[]
function floorAndCeil($arr,
                      $n, $x)
{
    // Indexes of floor
    // and ceiling
    $fInd = 0;
    $cInd = 0;
  
    // Distances of current
    // floor and ceiling
    $fDist = 999999;
    $cDist = 999999;
  
    for ($i = 0; $i < $n; $i++)
    {
        // If current element 
        // is closer than
        // previous ceiling.
        if ($arr[$i] >= $x && 
            $cDist > ($arr[$i] - $x))
        {
            $cInd = $i;
            $cDist = $arr[$i] - $x;
        }
  
        // If current element 
        // is closer than
        // previous floor.
        if ($arr[$i] <= $x && 
            $fDist > ($x - $arr[$i]))
        {
            $fInd = $i;
            $fDist = $x - $arr[$i];
        }
    }
  
    if ($fDist == 999999)
        echo "Floor doesn't "
             "exist " . "\n" ;
    else
        echo "Floor is "
              $arr[$fInd] . "\n";
  
    if ($cDist == 999999)
        echo "Ceil doesn't " .
             "exist " . "\n";
    else
        echo "Ceil is "
             $arr[$cInd] . "\n";
}
  
// Driver code
$arr = array(5, 6, 8, 9,
             6, 5, 5, 6);
$n = count($arr);
$x = 7;
floorAndCeil($arr, $n, $x);
  
// This code is contributed
// by Sam007
?>

chevron_right



Output :

Floor is 6
Ceil is 8

Time Complexity : O(n)
Auxiliary Space : O(1)

Related Articles :
Ceiling in a sorted array
Floor in a sorted array

This article is contributed by DANISH_RAZA. If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.



My Personal Notes arrow_drop_up



Article Tags :
Practice Tags :


Be the First to upvote.


Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.