# Find k closest numbers in an unsorted array

Here given code implementation process.

``````//C Program
//Find k closest numbers in an unsorted array
#include <stdio.h>

//Swap two element in array
void swap(int arr[],int first,int second)
{
int auxiliary=arr[first];
arr[first]=arr[second];
arr[second]=auxiliary;
}

int compare(int arr[],int left,int right,int root,int size)
{
int location = -1;

if(left < size &&  arr[left] > arr[root] )
{

if(right < size && arr[right] > arr[left])
{
swap(arr,right,root);
location = right;
}
else
{
swap(arr,left,root);
location = left;
}
}
else if(right < size && arr[right] > arr[root])
{
swap(arr,right,root);
location = right;
}
return location;
}
void heap(int arr[],int size,int root)
{
int left  = 2*root+1;
int right = 2*root+2;

int next_in = compare(arr, left, right, root, size);

if(next_in != -1)
{
heap(arr,size,next_in);
}
}
void print_array(int arr[],int size)
{
printf("\n");
for(int i = 0; i < size; i++)
{
printf("%3d",arr[i] );
}
}
void sort_element(int arr[],int size)
{

for (int i = (size/2)-1; i >= 0; i--)
{
heap(arr,size,i);
}
for (int i = size-1; i >= 0; i--)
{
swap(arr, 0, i);
heap(arr, i, 0);
}
}
//Compare the value of i and j to value x and return smallest difference location
int difference(int arr[],int i,int j,int x)
{
int first = arr[i]-x;
int second = arr[j]-x;

if(first<0)
{
first=-first;
}
if(second<0)
{
second=-second;
}
if(first > second)
{
return j;
}
else
{
return i;
}
}
//Display k closest elements of value x in given array
void closest_k(int arr[],int size,int x,int k)
{

if(k > size)
{
//invalid possibility
return;
}
//first sort array element
sort_element(arr,size);

int location=-1,back=0,i=0,temp=0;

//Find First element which is less than or equal to given value x
for (i = 0; i < size; ++i)
{
if(x <= arr[i])
{
location  = i;
break;
}
}

if(location==-1)
{
if(x > arr[size-1])
{
//point to last element
location = size-1;
}
else
{
//point to first element
location = 0;
}
}
back=location-1;
printf(" Nearest %d elements of value %d is :\n",k,x );

i = 0;
while(i < k)
{
if(location <size && back>-1)
{
temp = difference(arr,back,location,x);

printf(" %d ",arr[temp] );

if(temp == location)
{
location++;
}
else
{
back--;
}

}
else if(location < size)
{
printf(" %d ",arr[location] );
location++;

}
else if(back>0)
{
printf(" %d",arr[back] );
back--;

}
i++;
}
printf("\n");
}

int main()
{
//Define Collection of array elements
int arr[] = {4, 2, 1, 10, 15, 17, 20 , 14, 5};

//Get the size of array
int size = sizeof(arr)/sizeof(arr);

// x is value
// k is size of closest element
int x = 9, k = 4;

closest_k(arr,size,x,k);

return 0;
}```
```

#### Output

`````` Nearest 4 elements of value 9 is :
10  5  4  14``````
``````#include<iostream>

using namespace std;

/*
C++ Program
Find k closest numbers in an unsorted array
*/
class MyHeap {
public:

//Swap two element in array
void swap(int arr[], int first, int second) {
int auxiliary = arr[first];
arr[first] = arr[second];
arr[second] = auxiliary;
}
int compare(int arr[], int left, int right, int root, int size) {
int location = -1;
if (left < size && arr[left] > arr[root]) {
if (right < size && arr[right] > arr[left]) {
this->swap(arr, right, root);
location = right;
} else {
this->swap(arr, left, root);
location = left;
}
} else
if (right < size && arr[right] > arr[root]) {
this->swap(arr, right, root);
location = right;
}
return location;
}
void heap(int arr[], int size, int root) {
int left = 2 *root + 1;
int right = 2 *root + 2;
int next_in = this->compare(arr, left, right, root, size);
if (next_in != -1) {
this->heap(arr, size, next_in);
}
}
void print_array(int arr[], int size) {
cout << "\n";
for (int i = 0; i < size; i++) {
cout << " " << arr[i];
}
}
void sort_element(int arr[], int size) {
for (int i = (size / 2) - 1; i >= 0; i--) {
this->heap(arr, size, i);
}
for (int i = size - 1; i >= 0; i--) {
this->swap(arr, 0, i);
this->heap(arr, i, 0);
}
}
//Compare the value of i and j to value x and return smallest difference location
int difference(int arr[], int i, int j, int x) {
int first = arr[i] - x;
int second = arr[j] - x;
if (first < 0) {
first = -first;
}
if (second < 0) {
second = -second;
}
if (first > second) {
return j;
} else {
return i;
}
}
//Display k closest elements of value x in given array
void closest_k(int arr[], int size, int x, int k) {
if (k > size) {
//invalid possibility

return;
}
//first sort array element
this->sort_element(arr, size);
int location = -1, back = 0, i = 0, temp = 0;
//Find First element which is less than or equal to given value x

for (i = 0; i < size; ++i) {
if (x <= arr[i]) {
location = i;
break;
}
}
if (location == -1) {
if (x > arr[size - 1]) {
//point to last element
location = size - 1;
} else {
//point to first element
location = 0;
}
}
back = location - 1;
i = 0;
cout << " Nearest " << k << " elements of value " << x << " is :\n";
while (i < k) {
if (location < size && back > -1) {
temp = this->difference(arr, back, location, x);
cout << " " << arr[temp];
if (temp == location) {
location++;
} else {
back--;
}
i++;
} else
if (location < size) {
cout << " " << arr[location];
location++;
i++;
} else
if (back > 0) {
cout << " " << arr[location];
back--;
i++;
}
}
cout << "\n";
}
};
int main() {
MyHeap obj = MyHeap();
int arr[] = {
4,
2,
1,
10,
15,
17,
20,
14,
5
};
//Get the size of array
int size = sizeof(arr) / sizeof(arr);
// x is value
// k is size of closest element
int x = 9, k = 4;
obj.closest_k(arr, size, x, k);
return 0;
}```
```

#### Output

`````` Nearest 4 elements of value 9 is :
10 5 4 14``````
``````/*
Java Program
Find k closest numbers in an unsorted array
*/
public class MyHeap {

//Swap two element in array
public void swap(int []arr,int first,int second)
{
int auxiliary=arr[first];
arr[first]=arr[second];
arr[second]=auxiliary;
}

public int compare(int []arr,int left,int right,int root,int size)
{
int location = -1;

if(left < size &&  arr[left] > arr[root] )
{

if(right < size && arr[right] > arr[left])
{
swap(arr,right,root);
location = right;
}
else
{
swap(arr,left,root);
location = left;
}
}
else if(right < size && arr[right] > arr[root])
{
swap(arr,right,root);
location = right;
}
return location;
}
public void heap(int []arr,int size,int root)
{
int left  = 2*root+1;
int right = 2*root+2;

int next_in = compare(arr, left, right, root, size);

if(next_in != -1)
{
heap(arr,size,next_in);
}
}
public void print_array(int []arr,int size)
{
System.out.print("\n");
for(int i = 0; i < size; i++)
{
System.out.print("  "+arr[i] );
}
}
public void sort_element(int []arr,int size)
{

for (int i = (size/2)-1; i >= 0; i--)
{
heap(arr,size,i);
}
for (int i = size-1; i >= 0; i--)
{
swap(arr, 0, i);
heap(arr, i, 0);
}
}
//Compare the value of i and j to value x and return smallest difference location
public int difference(int []arr,int i,int j,int x)
{
int first = arr[i]-x;
int second = arr[j]-x;

if(first<0)
{
first=-first;
}
if(second<0)
{
second=-second;
}
if(first > second)
{
return j;
}
else
{
return i;
}
}
//Display k closest elements of value x in given array
public void closest_k(int []arr,int size,int x,int k)
{

if(k > size)
{
//invalid possibility
return;
}
//first sort array element
sort_element(arr,size);

int location=-1,back=0,i=0,temp=0;

//Find First element which is less than or equal to given value x
for (i = 0; i < size; ++i)
{
if(x <= arr[i])
{
location  = i;
break;
}
}

if(location==-1)
{
if(x > arr[size-1])
{
//point to last element
location = size-1;
}
else
{
//point to first element
location = 0;
}
}
back=location-1;
i = 0;
System.out.print(" Nearest "+k+" elements of value "+x+" is :\n");
while(i < k)
{
if(location <size && back>-1)
{
temp = difference(arr,back,location,x);

System.out.print(" "+arr[temp] );

if(temp == location)
{
location++;
}
else
{
back--;
}
i++;
}
else if(location < size)
{
System.out.print(" "+arr[location] );
location++;
i++;
}
else if(back>0)
{
System.out.print(" "+arr[location] );
back--;
i++;
}
}
System.out.print("\n");
}
public static void main(String[] args) {

MyHeap obj = new MyHeap();

//Define Collection of array elements
int []arr = {4, 2, 1, 10, 15, 17, 20 , 14, 5};

//Get the size of array
int size = arr.length;

// x is value
// k is size of closest element
int x = 9, k = 4;

obj.closest_k(arr,size,x,k);
}
}```
```

#### Output

`````` Nearest 4 elements of value 9 is :
10 5 4 14``````
``````/*
C# Program
Find k closest numbers in an unsorted array
*/
using System;

public class MyHeap {
//Swap two element in array
public void swap(int[] arr, int first, int second) {
int auxiliary = arr[first];
arr[first] = arr[second];
arr[second] = auxiliary;
}
public int compare(int[] arr, int left, int right, int root, int size) {
int location = -1;
if (left < size && arr[left] > arr[root]) {
if (right < size && arr[right] > arr[left]) {
swap(arr, right, root);
location = right;
} else {
swap(arr, left, root);
location = left;
}
} else
if (right < size && arr[right] > arr[root]) {
swap(arr, right, root);
location = right;
}
return location;
}
public void heap(int[] arr, int size, int root) {
int left = 2 * root + 1;
int right = 2 * root + 2;
int next_in = compare(arr, left, right, root, size);
if (next_in != -1) {
heap(arr, size, next_in);
}
}
public void print_array(int[] arr, int size) {
Console.Write("\n");
for (int i = 0; i < size; i++) {
Console.Write(" " + arr[i]);
}
}
public void sort_element(int[] arr, int size) {
for (int i = (size / 2) - 1; i >= 0; i--) {
heap(arr, size, i);
}
for (int i = size - 1; i >= 0; i--) {
swap(arr, 0, i);
heap(arr, i, 0);
}
}
//Compare the value of i and j to value x and return smallest difference location
public int difference(int[] arr, int i, int j, int x) {
int first = arr[i] - x;
int second = arr[j] - x;
if (first < 0) {
first = -first;
}
if (second < 0) {
second = -second;
}
if (first > second) {
return j;
} else {
return i;
}
}
//Display k closest elements of value x in given array
public void closest_k(int[] arr, int size, int x, int k) {
if (k > size) {
return;
}
sort_element(arr, size);
int location = -1, back = 0, i = 0, temp = 0;
//Find First element which is less than or equal to given value x

for (i = 0; i < size; ++i) {
if (x <= arr[i]) {
location = i;
break;;
}
}
if (location == -1) {
if (x > arr[size - 1]) {
//point to last element
location = size - 1;
} else {
//point to first element
location = 0;
}
}
back = location - 1;
i = 0;
Console.Write(" Nearest " + k + " elements of value " + x + " is :\n");
while (i < k) {
if (location < size && back > -1) {
temp = difference(arr, back, location, x);
Console.Write(" " + arr[temp]);
if (temp == location) {
location++;
} else {
back--;
}
i++;
} else
if (location < size) {
Console.Write(" " + arr[location]);
location++;
i++;
} else
if (back > 0) {
Console.Write(" " + arr[location]);
back--;
i++;
}
}
Console.Write("\n");
}
public static void Main(String[] args) {
MyHeap obj = new MyHeap();
int[]
//Define Collection of array elements
arr = {
4,
2,
1,
10,
15,
17,
20,
14,
5
};
//Get the size of array
int size = arr.Length;
// x is value
// k is size of closest element
int x = 9, k = 4;
obj.closest_k(arr, size, x, k);
}
}```
```

#### Output

`````` Nearest 4 elements of value 9 is :
10 5 4 14``````
``````<?php
/*
Php Program
Find k closest numbers in an unsorted array
*/
class MyHeap {
//Swap two element in array

public 	function swap(&\$arr, \$first, \$second) {
\$auxiliary = \$arr[\$first];
\$arr[\$first] = \$arr[\$second];
\$arr[\$second] = \$auxiliary;
}
public 	function compare(&\$arr, \$left, \$right, \$root, \$size) {
\$location = -1;
if (\$left < \$size && \$arr[\$left] > \$arr[\$root]) {
if (\$right < \$size && \$arr[\$right] > \$arr[\$left]) {
\$this->swap(\$arr, \$right, \$root);
\$location = \$right;
} else {
\$this->swap(\$arr, \$left, \$root);
\$location = \$left;
}
} else
if (\$right < \$size && \$arr[\$right] > \$arr[\$root]) {
\$this->swap(\$arr, \$right, \$root);
\$location = \$right;
}
return \$location;
}
public 	function heap(&\$arr, \$size, \$root) {
\$left = 2 *\$root + 1;
\$right = 2 *\$root + 2;
\$next_in = \$this->compare(\$arr, \$left, \$right, \$root, \$size);
if (\$next_in != -1) {
\$this->heap(\$arr, \$size, \$next_in);
}
}
public 	function print_array(\$arr, \$size) {
echo("\n");
for (\$i = 0; \$i < \$size; \$i++) {
echo(" ". \$arr[\$i]);
}
}
public 	function sort_element(&\$arr, \$size) {
for (\$i = (intval(\$size / 2)) - 1; \$i >= 0; \$i--) {
\$this->heap(\$arr, \$size, \$i);
}
for (\$i = \$size - 1; \$i >= 0; \$i--) {
\$this->swap(\$arr, 0, \$i);
\$this->heap(\$arr, \$i, 0);
}
}
//Compare the value of i and j to value x and return smallest difference location
public 	function difference(\$arr, \$i, \$j, \$x) {
\$first = \$arr[\$i] - \$x;
\$second = \$arr[\$j] - \$x;
if (\$first < 0) {
\$first = -\$first;
}
if (\$second < 0) {
\$second = -\$second;
}
if (\$first > \$second) {
return \$j;
} else {
return \$i;
}
}
//Display k closest elements of value x in given array
public 	function closest_k(&\$arr, \$size, \$x, \$k) {
if (\$k > \$size) {
return;
}
//first sort array element
\$this->sort_element(\$arr, \$size);
\$location = -1;
\$back = 0;
\$i = 0;
\$temp = 0;
//Find First element which is less than or equal to given value x
for (\$i = 0; \$i < \$size; ++\$i) {
if (\$x <= \$arr[\$i]) {
\$location = \$i;
break;
}
}
if (\$location == -1) {
if (\$x > \$arr[\$size - 1]) {
//point to last element
\$location = \$size - 1;
} else {
//point to first element
\$location = 0;
}
}
\$back = \$location - 1;
\$i = 0;
echo(" Nearest ". \$k ." elements of value ". \$x ." is :\n");
while (\$i < \$k) {
if (\$location < \$size && \$back > -1) {
\$temp = \$this->difference(\$arr, \$back, \$location, \$x);
echo(" ". \$arr[\$temp]);
if (\$temp == \$location) {
\$location++;
} else {
\$back--;
}
\$i++;
} else
if (\$location < \$size) {
echo(" ". \$arr[\$location]);
\$location++;
\$i++;
} else
if (\$back > 0) {
echo(" ". \$arr[\$location]);
\$back--;
\$i++;
}
}
echo("\n");
}
}

function main() {
\$obj = new MyHeap();
//Define Collection of array elements
\$arr = array(4, 2, 1, 10, 15, 17, 20, 14, 5);
//Get the size of array
\$size = count(\$arr);
// x is value
// k is size of closest element
\$x = 9;
\$k = 4;
\$obj->closest_k(\$arr, \$size, \$x, \$k);

}
main();```
```

#### Output

`````` Nearest 4 elements of value 9 is :
10 5 4 14``````
``````/*
Node Js Program
Find k closest numbers in an unsorted array
*/
class MyHeap {
//Swap two element in array
swap(arr, first, second) {
var auxiliary = arr[first];
arr[first] = arr[second];
arr[second] = auxiliary;
}
compare(arr, left, right, root, size) {
var location = -1;
if (left < size && arr[left] > arr[root]) {
if (right < size && arr[right] > arr[left]) {
this.swap(arr, right, root);
location = right;
} else {
this.swap(arr, left, root);
location = left;
}
} else
if (right < size && arr[right] > arr[root]) {
this.swap(arr, right, root);
location = right;
}

return location;
}
heap(arr, size, root) {
var left = 2 *root + 1;
var right = 2 *root + 2;
var next_in = this.compare(arr, left, right, root, size);
if (next_in != -1) {
this.heap(arr, size, next_in);
}
}
print_array(arr, size) {
process.stdout.write("\n");
for (var i = 0; i < size; i++) {
process.stdout.write(" " + arr[i]);
}
}
sort_element(arr, size) {
for (var i = (parseInt(size / 2)) - 1; i >= 0; i--) {
this.heap(arr, size, i);
}

for (var i = size - 1; i >= 0; i--) {
this.swap(arr, 0, i);
this.heap(arr, i, 0);
}
}

//Compare the value of i and j to value x and return smallest difference location
difference(arr, i, j, x) {
var first = arr[i] - x;
var second = arr[j] - x;
if (first < 0) {
first = -first;
}

if (second < 0) {
second = -second;
}

if (first > second) {
return j;
} else {
return i;
}
}

//Display k closest elements of value x in given array
closest_k(arr, size, x, k) {
if (k > size) {
return;
}

//first sort array element
this.sort_element(arr, size);
var location = -1;
var back = 0;
var i = 0;
var temp = 0;
//Find First element which is less than or equal to given value x

for (i = 0; i < size; ++i) {
if (x <= arr[i]) {
location = i;
break;
}
}

if (location == -1) {
if (x > arr[size - 1]) {
//point to last element
location = size - 1;
} else {
//point to first element
location = 0;
}
}
back = location - 1;
i = 0;
process.stdout.write(" Nearest " + k + " elements of value " + x + " is :\n");
while (i < k) {
if (location < size && back > -1) {
temp = this.difference(arr, back, location, x);
process.stdout.write(" " + arr[temp]);
if (temp == location) {
location++;
} else {
back--;
}
i++;
} else
if (location < size) {
process.stdout.write(" " + arr[location]);
location++;
i++;
} else
if (back > 0) {
process.stdout.write(" " + arr[location]);
back--;
i++;
}
}

process.stdout.write("\n");
}
}

function main(args) {
var obj = new MyHeap();
//Define Collection of array elements
var arr = [4, 2, 1, 10, 15, 17, 20, 14, 5];
//Get the size of array
var size = arr.length;
// x is value
// k is size of closest element
var x = 9;
var k = 4;
obj.closest_k(arr, size, x, k);
}

main();```
```

#### Output

`````` Nearest 4 elements of value 9 is :
10 5 4 14``````
``````# Python 3 Program
# Find k closest numbers in an unsorted array
class MyHeap :
# Swap two element in array
def swap(self, arr, first, second) :
auxiliary = arr[first]
arr[first] = arr[second]
arr[second] = auxiliary

def compare(self, arr, left, right, root, size) :
location = -1
if (left < size and arr[left] > arr[root]) :
if (right < size and arr[right] > arr[left]) :
self.swap(arr, right, root)
location = right
else :
self.swap(arr, left, root)
location = left

elif (right < size and arr[right] > arr[root]) :
self.swap(arr, right, root)
location = right

return location

def heap(self, arr, size, root) :
left = 2 * root + 1
right = 2 * root + 2
next_in = self.compare(arr, left, right, root, size)
if (next_in != -1) :
self.heap(arr, size, next_in)

def print_array(self, arr, size) :
print("\n", end = "")
i = 0
while (i < size) :
print(" ", arr[i], end = "")
i += 1

def sort_element(self, arr, size) :
i = (int(size / 2)) - 1
while (i >= 0) :
self.heap(arr, size, i)
i -= 1

i = size - 1
while (i >= 0) :
self.swap(arr, 0, i)
self.heap(arr, i, 0)
i -= 1

# Compare the value of i and j to value x and return smallest difference location
def difference(self, arr, i, j, x) :
first = arr[i] - x
second = arr[j] - x
if (first < 0) :
first = -first

if (second < 0) :
second = -second

if (first > second) :
return j
else :
return i

# Display k closest elements of value x in given array
def closest_k(self, arr, size, x, k) :
if (k > size) :
return

self.sort_element(arr, size)
location = -1
back = 0
i = 0
temp = 0
# Find First element which is less than or equal to given value x
i = 0
while (i < size) :
if (x <= arr[i]) :
location = i
break

i += 1

if (location == -1) :
if (x > arr[size - 1]) :
# point to last element
location = size - 1
else :
# point to first element
location = 0

back = location - 1
i = 0
print(" Nearest ", k ," elements of value ", x ," is :\n", end = "")
while (i < k) :
if (location < size and back > -1) :
temp = self.difference(arr, back, location, x)
print(" ", arr[temp], end = "")
if (temp == location) :
location += 1
else :
back -= 1

i += 1
elif (location < size) :
print(" ", arr[location], end = "")
location += 1
i += 1
elif (back > 0) :
print(" ", arr[location], end = "")
back -= 1
i += 1

print("\n", end = "")

def main() :
obj = MyHeap()
# Define Collection of array elements
arr = [4, 2, 1, 10, 15, 17, 20, 14, 5]
# Get the size of array
size = len(arr)
#  k is size of closest element
#  x is value
#  k is size of closest element
x = 9
k = 4
obj.closest_k(arr, size, x, k)

if __name__ == "__main__":
main()```
```

#### Output

`````` Nearest  4  elements of value  9  is :
10  5  4  14``````
``````# Ruby Program
# Find k closest numbers in an unsorted array
class MyHeap
# Swap two element in array
def swap(arr, first, second)
auxiliary = arr[first]
arr[first] = arr[second]
arr[second] = auxiliary
end
def compare(arr, left, right, root, size)
location = -1
if (left < size && arr[left] > arr[root])
if (right < size && arr[right] > arr[left])
self.swap(arr, right, root)
location = right
else
self.swap(arr, left, root)
location = left
end
elsif (right < size && arr[right] > arr[root])
self.swap(arr, right, root)
location = right

end
return location
end
def heap(arr, size, root)
left = 2 * root + 1
right = 2 * root + 2
next_in = self.compare(arr, left, right, root, size)
if (next_in != -1)
self.heap(arr, size, next_in)
end
end
def print_array(arr, size)
print("\n")
i = 0
while (i < size)
print(" ", arr[i])
i += 1
end
end
def sort_element(arr, size)
i = (size / 2) - 1
while (i >= 0)
self.heap(arr, size, i)
i -= 1
end
i = size - 1
while (i >= 0)
self.swap(arr, 0, i)
self.heap(arr, i, 0)
i -= 1
end
end
# Compare the value of i and j to value x and return smallest difference location
def difference(arr, i, j, x)
first = arr[i] - x
second = arr[j] - x
if (first < 0)
first = -first
end
if (second < 0)
second = -second
end
if (first > second)
return j
else
return i
end
end
# Display k closest elements of value x in given array
def closest_k(arr, size, x, k)
if (k > size)
return
end
self.sort_element(arr, size)
location = -1
back = 0
i = 0
temp = 0
# Find First element which is less than or equal to given value x
i = 0
while (i < size)
if (x <= arr[i])
location = i
break
end
i += 1
end
if (location == -1)
if (x > arr[size - 1])
# point to last element
location = size - 1
else
# point to first element
location = 0
end
end
back = location - 1
i = 0
print(" Nearest ", k ," elements of value ", x ," is  :\n")
while (i < k)
if (location < size && back > -1)
temp = self.difference(arr, back, location, x)
print(" ", arr[temp])
if (temp == location)
location += 1
else
back -= 1
end
i += 1
elsif (location < size)
print(" ", arr[location])
location += 1
i += 1
elsif (back > 0)
print(" ", arr[location])
back -= 1
i += 1
end
end
print("\n")
end
end
def main()
obj = MyHeap.new()
# Define Collection of array elements
arr = [4, 2, 1, 10, 15, 17, 20, 14, 5]
# Get the size of array
size = arr.length
#  k is size of closest element
#  x is value
#  k is size of closest element
x = 9
k = 4
obj.closest_k(arr, size, x, k)
end
main()```
```

#### Output

`````` Nearest 4 elements of value 9 is  :
10 5 4 14
``````
``````/*
Scala Program
Find k closest numbers in an unsorted array
*/
class MyHeap {
//Swap two element in array
def swap(arr: Array[Int], first: Int, second: Int): Unit = {
val auxiliary: Int = arr(first);
arr(first) = arr(second);
arr(second) = auxiliary;
}
def compare(arr: Array[Int], left: Int, right: Int, root: Int, size: Int): Int = {
var location: Int = -1;

if (left < size && arr(left) > arr(root)) {
if (right < size && arr(right) > arr(left)) {
this.swap(arr, right, root);
location = right;
} else {
this.swap(arr, left, root);
location = left;
}
} else
if (right < size && arr(right) > arr(root)) {
this.swap(arr, right, root);
location = right;
}
return location;
}
def heap(arr: Array[Int], size: Int, root: Int): Unit = {
val left: Int = 2 * root + 1;
val right: Int = 2 * root + 2;
val next_in: Int = this.compare(arr, left, right, root, size);

if (next_in != -1) {
this.heap(arr, size, next_in);
}
}
def print_array(arr: Array[Int], size: Int): Unit = {
print("\n");
var i: Int = 0;
while (i < size) {
print(" " + arr(i));
i += 1;
}
}
def sort_element(arr: Array[Int], size: Int): Unit = {
var i: Int = ((size / 2).toInt) - 1;
while (i >= 0) {
this.heap(arr, size, i);
i -= 1;
}
i = size - 1;
while (i >= 0) {
this.swap(arr, 0, i);
this.heap(arr, i, 0);
i -= 1;
}
}
//Compare the value of i and j to value x and return smallest difference location
def difference(arr: Array[Int], i: Int, j: Int, x: Int): Int = {
var first: Int = arr(i) - x;
var second: Int = arr(j) - x;

if (first < 0) {
first = -first;
}
if (second < 0) {
second = -second;
}
if (first > second) {
return j;
} else {
return i;
}
}
//Display k closest elements of value x in given array
def closest_k(arr: Array[Int], size: Int, x: Int, k: Int): Unit = {
if (k > size) {
return;
}
this.sort_element(arr, size);
var location: Int = -1;
var back: Int = 0;
var i: Int = 0;
var temp: Int = 0;

//Find First element which is less than or equal to given value x
i = 0;
while (i < size && location == -1) {
if (x <= arr(i)) {
location = i;
}
i += 1;
}
if (location == -1) {
if (x > arr(size - 1)) {
//point to last element
location = size - 1;
} else {
//point to first element
location = 0;
}
}
back = location - 1;
i = 0;
print(" Nearest " + k + " elements of value " + x + " is :\n");
while (i < k) {
if (location < size && back > -1) {
temp = this.difference(arr, back, location, x);
print(" " + arr(temp));

if (temp == location) {
location += 1;
} else {
back -= 1;
}
i += 1;
} else
if (location < size) {
print(" " + arr(location));
location += 1;
i += 1;
} else
if (back > 0) {
print(" " + arr(location));
back -= 1;
i += 1;
}
}
print("\n");
}
}
object Main {
def main(args: Array[String]): Unit = {
val obj: MyHeap = new MyHeap();

//Define Collection of array elements
var arr: Array[Int] = Array(4, 2, 1, 10, 15, 17, 20, 14, 5);

//Get the size of array
val size: Int = arr.length;

// x is value
// k is size of closest element
val x: Int = 9;
val k: Int = 4;
obj.closest_k(arr, size, x, k);
}
}```
```

#### Output

`````` Nearest 4 elements of value 9 is :
10 5 4 14``````
``````/*
Swift Program
Find k closest numbers in an unsorted array
*/
class MyHeap {
//Swap two element in array
func swap(_ arr: inout [Int], _ first: Int, _ second: Int) {
let auxiliary: Int = arr[first];
arr[first] = arr[second];
arr[second] = auxiliary;
}
func compare(_ arr: inout [Int], _ left: Int, _ right: Int, _ root: Int, _ size: Int) -> Int {
var location: Int = -1;
if (left < size && arr[left] > arr[root]) {
if (right < size && arr[right] > arr[left]) {
self.swap(&arr, right, root);
location = right;
} else {
self.swap(&arr, left, root);
location = left;
}
} else
if (right < size && arr[right] > arr[root]) {
self.swap(&arr, right, root);
location = right;
}
return location;
}
func heap(_ arr: inout [Int], _ size: Int, _ root: Int) {
let left: Int = 2 * root + 1;
let right: Int = 2 * root + 2;
let next_in: Int = self.compare(&arr, left, right, root, size);
if (next_in != -1) {
self.heap(&arr, size, next_in);
}
}
func print_array(_ arr: [Int], _ size: Int) {
print("\n", terminator: "");
var i: Int = 0;
while (i < size) {
print(" ", arr[i], terminator: "");
i += 1;
}
}
func sort_element(_ arr: inout [Int], _ size: Int) {
var i: Int = (size / 2) - 1;
while (i >= 0) {
self.heap(&arr, size, i);
i -= 1;
}
i = size - 1;
while (i >= 0) {
self.swap(&arr, 0, i);
self.heap(&arr, i, 0);
i -= 1;
}
}
//Compare the value of i and j to value x and return smallest difference location
func difference(_ arr: [Int], _ i: Int, _ j: Int, _ x: Int) -> Int {
var first: Int = arr[i] - x;
var second: Int = arr[j] - x;
if (first < 0) {
first = -first;
}
if (second < 0) {
second = -second;
}
if (first > second) {
return j;
} else {
return i;
}
}
//Display k closest elements of value x in given array
func closest_k(_ arr: inout [Int], _ size: Int, _ x: Int, _ k: Int) {
if (k > size) {
return;
}
self.sort_element(&arr, size);
var location: Int = -1;
var back: Int = 0;
var i: Int = 0;
var temp: Int = 0;
//Find First element which is less than or equal to given value x
i = 0;
while (i < size) {
if (x <= arr[i]) {
location = i;
break;
}
i += 1;
}
if (location == -1) {
if (x > arr[size - 1]) {
//point to last element
location = size - 1;
} else {
//point to first element
location = 0;
}
}
back = location - 1;
i = 0;
print(" Nearest ", k ," elements of value ", x ," is :\n", terminator: "");
while (i < k) {
if (location < size && back > -1) {
temp = self.difference(arr, back, location, x);
print(" ", arr[temp], terminator: "");
if (temp == location) {
location += 1;
} else {
back -= 1;
}
i += 1;
} else
if (location < size) {
print(" ", arr[location], terminator: "");
location += 1;
i += 1;
} else
if (back > 0) {
print(" ", arr[location], terminator: "");
back -= 1;
i += 1;
}
}
print("\n", terminator: "");
}
}
func main() {
let obj: MyHeap = MyHeap();
//Define Collection of array elements
var arr: [Int] = [4, 2, 1, 10, 15, 17, 20, 14, 5];
//Get the size of array
let size: Int = arr.count;
// x is value
// k is size of closest element
let x: Int = 9;
let k: Int = 4;
obj.closest_k(&arr, size, x, k);
}
main();```
```

#### Output

`````` Nearest  4  elements of value  9  is :
10  5  4  14``````

## Comment

Please share your knowledge to improve code and content standard. Also submit your doubts, and test case. We improve by your feedback. We will try to resolve your query as soon as possible.