Given - a number (n) and a sorted array
Find a number in the array having least difference with the given number (n).
First approach-
-if there is only one element return that element
-check if it is less than first element of array then return first element
-check if it is greater than the last element of the array then return last element
-if there are two elements return the nearest element
-else find the mid use modified binary search to return the nearest
O(lgn)
Second approach:
Can we use interval tree some how?
O(lgn)
package com.zhuyu_deng.test;
import java.util.Arrays;
public class Test
{
public static void main(String args[])
{
int a[]={31, 34, 50};
// int a[]={30};
// int a[]={40, 50};
// int a[]={20, 30};
// int a[]={30, 40};
for (int i = 0; i < a.length; ++i)
System.out.print(a[i] + " ");
System.out.println();
System.out.println("ans is : ");
int x = findMinDifNum(a, 34);
System.out.println(x);
}
private static int findMinDifNum(int[] a, int n)
{
if (a.length == 1)
return a[0];
else if (a[0] > n)
{
return a[0];
}
else if (a[a.length-1] < n)
{
return a[a.length-1];
}else if (a.length == 2)
{
return n - a[0] > a[1] - n ? a[1] : a[0];
}
int left = 0;
int right = a.length - 1;
int mid = 0;
while (left <= right)
{
mid = (left + right) / 2;
if (a[mid] < n)
left = mid + 1;
else if (a[mid] > n)
right = mid - 1;
else
break;
}
if (left <= right)
return a[mid];
if (a[mid] < n)
{
return n-a[mid] > a[mid+1] - n ? a[mid+1] : a[mid];
}
else
{
return a[mid] - n > n - a[mid-1] ? a[mid-1] : a[mid];
}
}
}