找差值最小的数

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