 GeeksforGeeks App
Open App Browser
Continue

# 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 greatest 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.```
Recommended Practice

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.

## C++

 `#include ``using` `namespace` `std;` `// Solution``vector<``int``> floorAndCeil(vector<``int``> arr, ``int` `n, ``int` `x)``{``    ``vector<``int``> result(2);` `    ``int` `low = 0, high = n - 1;` `    ``while` `(low <= high) {``        ``int` `mid = low + (high - low) / 2;``        ``if` `(arr[mid] > x) {``            ``high = mid - 1;``        ``}``        ``else` `if` `(arr[mid] < x) {``            ``low = mid + 1;``        ``}``        ``else` `{``            ``result = arr[mid];``            ``result = arr[mid];``            ``return` `result;``        ``}``    ``}` `    ``// if loop breaks``    ``result = (high == -1) ? -1 : arr[high];``    ``result = (low == arr.size()) ? -1 : arr[low];` `    ``return` `result;``}` `// Driver``int` `main()``{``    ``vector<``int``> arr = { 5, 6, 8, 9, 6, 5, 5, 6 };``    ``int` `n = arr.size();``    ``int` `x = 7;` `    ``vector<``int``> result = floorAndCeil(arr, n, x);``    ``cout << ``"floor is "` `<< result << endl;``    ``cout << ``"ceil is "` `<< result << endl;``    ``return` `0;``} ``// this code is contributed by devendradany`

## Java

 `import` `java.util.*;` `public` `class` `Main {` `    ``// Solution``    ``public` `static` `int``[] floorAndCeil(``int``[] arr, ``int` `n,``                                     ``int` `x)``    ``{` `        ``int``[] result = ``new` `int``[``2``];` `        ``int` `low = ``0``, high = n - ``1``;` `        ``while` `(low <= high) {``            ``int` `mid = low + (high - low) / ``2``;``            ``if` `(arr[mid] > x) {``                ``high = mid - ``1``;``            ``}``            ``else` `if` `(arr[mid] < x) {``                ``low = mid + ``1``;``            ``}``            ``else` `{``                ``Arrays.fill(result, arr[mid]);``                ``return` `result;``            ``}``        ``}` `        ``// if loop breaks``        ``result[``0``] = (high == -``1``) ? -``1` `: arr[high];``        ``result[``1``] = (low == arr.length) ? -``1` `: arr[low];` `        ``return` `result;``    ``}` `    ``// Driver``    ``public` `static` `void` `main(String[] args)``    ``{` `        ``int``[] arr = { ``5``, ``6``, ``8``, ``9``, ``6``, ``5``, ``5``, ``6` `};``        ``int` `n = arr.length;``        ``int` `x = ``7``;` `        ``int``[] result = floorAndCeil(arr, n, x);``        ``System.out.println(``"floor is "` `+ result[``0``]);``        ``System.out.println(``"ceil is "` `+ result[``1``]);``    ``}``}`

## Python3

 `#Equivalent Python code for the given Java code` `#The binary search algorithm used in the code can be implemented similarly in Python` `def` `floor_and_ceil(arr, n, x):``    ``result ``=` `[``0``, ``0``]` `    ``low ``=` `0``    ``high ``=` `n ``-` `1` `    ``while` `low <``=` `high:``        ``mid ``=` `low ``+` `(high ``-` `low) ``/``/` `2``        ``if` `arr[mid] > x:``            ``high ``=` `mid ``-` `1``        ``elif` `arr[mid] < x:``            ``low ``=` `mid ``+` `1``        ``else``:``            ``result ``=` `[arr[mid], arr[mid]]``            ``return` `result` `    ``# if loop breaks``    ``result[``0``] ``=` `-``1` `if` `high ``=``=` `-``1` `else` `arr[high]``    ``result[``1``] ``=` `-``1` `if` `low ``=``=` `n ``else` `arr[low]` `    ``return` `result` `if` `__name__ ``=``=` `'__main__'``:``    ``arr ``=` `[``5``, ``6``, ``8``, ``9``, ``6``, ``5``, ``5``, ``6``]``    ``n ``=` `len``(arr)``    ``x ``=` `7``    ` `    ``result ``=` `floor_and_ceil(arr, n, x)``    ``print``(``"floor is"``, result[``0``])``    ``print``(``"ceil is"``, result[``1``])`

## C#

 `using` `System;` `public` `class` `GFG {` `  ``// Solution``  ``public` `static` `int``[] floorAndCeil(``int``[] arr, ``int` `n,``                                   ``int` `x)``  ``{` `    ``int``[] result = ``new` `int``;` `    ``int` `low = 0, high = n - 1;` `    ``while` `(low <= high) {``      ``int` `mid = low + (high - low) / 2;``      ``if` `(arr[mid] > x) {``        ``high = mid - 1;``      ``}``      ``else` `if` `(arr[mid] < x) {``        ``low = mid + 1;``      ``}``      ``else` `{``        ``result = arr[mid];``        ``result = arr[mid];``        ``return` `result;``      ``}``    ``}` `    ``// if loop breaks``    ``result = (high == -1) ? -1 : arr[high];``    ``result = (low == arr.Length) ? -1 : arr[low];` `    ``return` `result;``  ``}` `  ``static` `public` `void` `Main()``  ``{` `    ``int``[] arr = { 5, 6, 8, 9, 6, 5, 5, 6 };``    ``int` `n = arr.Length;``    ``int` `x = 7;` `    ``int``[] result = floorAndCeil(arr, n, x);``    ``Console.WriteLine(``"floor is "` `+ result);``    ``Console.WriteLine(``"ceil is "` `+ result);``  ``}``}` `// This code is contributed by akashish__`

## Javascript

 `// JavaScript code equivalent to given Python code` `function` `floorAndCeil(arr, n, x) {``let result = [0, 0];``let low = 0;``let high = n - 1;` `while` `(low <= high) {``    ``let mid = low + Math.floor((high - low) / 2);``    ``if` `(arr[mid] > x) {``        ``high = mid - 1;``    ``} ``else` `if` `(arr[mid] < x) {``        ``low = mid + 1;``    ``} ``else` `{``        ``result = [arr[mid], arr[mid]];``        ``return` `result;``    ``}``}` `// if loop breaks``result = (high == -1) ? -1 : arr[high];``result = (low == n) ? -1 : arr[low];` `return` `result;``}` `let arr = [5, 6, 8, 9, 6, 5, 5, 6];``let n = arr.length;``let x = 7;` `let result = floorAndCeil(arr, n, x);``console.log(``'floor is '``+result);``console.log(``'ceil is '``+result);`

Output

```floor is 6
ceil is 8```

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++ program to find floor and ceiling in an``// unsorted array.``#include``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= 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;``}`

## Java

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

## Python 3

 `# 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`

## C#

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

## PHP

 `= ``\$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``?>`

## Javascript

 ``

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 write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

My Personal Notes arrow_drop_up