二分查找及其若干变种

问题

在有序数组nums中，查找target

思路

递归。两个指针l, r开始分别指向有序数组nums的两端，计算mid为l和r的中点，判断mid处数组元素与target的大小关系，从而让l或r跳转到mid附近，实现数组的折半。然后在折半的数组中继续上述查找，直到找到或l跑到r后面。

具体实现可以用while循环或递归，while循环的实现由于函数调用少，因此时间开销较少。

两个要点

1. while循环条件是l <= r，如果是 < 的话会当l与r之间的数组长度为1时会直接跳出循环；

2. l和r跳转到mid+1和mid-1，如果跳转到mid的话当r = l + 1时可能造成死循环。

二分查找及其变式

1. 在有序序列中查找target的位置

2. 在有序序列中查找第一个大于等于target的位置

3. 在有序序列中查找第一个大于target的位置

4. 在有序序列中查找最后一个小于等于target的位置

5. 在有序序列中查找最后一个小于target的位置

public class Main
{
	/**
	 * Find {@code target} in ascending array {@code nums} and return its position
	 * return -1 if not found
	 * If there are several {@code target} in {@code nums}, 
	 * the returned position is arbitrary
	 */
	public static int findValue(int[] nums, int target)
	{
		int n = nums.length, l = 0, r = n-1, mid = 0;
		if (n == 0)
		{
			return -1;
		}
		while (l <= r)
		{
			mid = (l + r) / 2;
			if (nums[mid] == target)
			{
				return mid;
			}
			else if(nums[mid] < target)
			{
				l = mid + 1;
			}
			else
			{
				r = mid - 1;
			}
		}
		return -1;
	}

	/**
	 * find first element >= {@code target} in ascending array {@code nums}
	 */
	public static int findFirstGE(int[] nums, int target)
	{
		int n = nums.length, l = 0, r = n-1, mid = 0;
		if (n == 0)
		{
			return -1;
		}
		while (l <= r)
		{
			mid = (l + r) / 2;
			if (nums[mid] >= target)
			{
				r = mid - 1;
			}
			else
			{
				l = mid + 1;
			}
		}
		return l;
	} 

	/**
	 * find first element > {@code target} in ascending array {@code nums}
	 */
	public static int findFirstGT(int[] nums, int target)
	{
		int n = nums.length, l = 0, r = n-1, mid = 0;
		if (n == 0)
		{
			return -1;
		}
		while (l <= r)
		{
			mid = (l + r) / 2;
			if (nums[mid] > target)
			{
                r = mid - 1;				
			}
			else
			{
				l = mid + 1;
			}
		}
		return l;
	}
	
	/**
	 * find Last element <= {@code target} in ascending array {@code nums}
	 */
	public static int findLastLE(int[] nums, int target)
	{
		int n = nums.length, l = 0, r = n-1, mid = 0;
		if (n == 0)
		{
			return -1;
		}
		while (l <= r)
		{
			mid = (l + r) / 2;
			if (nums[mid] <= target)
			{
				l = mid + 1;
			}
			else
			{
				r = mid - 1;
			}
		}
		return r;
	}

	/**
	 * find Last element < {@code target} in ascending array {@code nums}
	 */
	public static int findLastLT(int[] nums, int target)
	{
		int n = nums.length, l = 0, r = n-1, mid = 0;
		if (n == 0)
		{
			return -1;
		}
		while (l <= r)
		{
			mid = (l + r) / 2;
			if (nums[mid] < target)
			{
				l = mid + 1;
			}
			else
			{
				r = mid - 1;
			}
		}
		return r;
	}
	
	public static void main(String[] args)
	{
		int[] arr = {1, 2, 2, 3, 3, 3, 5, 10, 20};
		System.out.println(findValue(arr, 3));
		System.out.println(findFirstGE(arr, 3));
		System.out.println(findFirstGT(arr, 3));
		System.out.println(findFirstLE(arr, 3));
		System.out.println(findFirstLT(arr, 3));
	}
}

输出：

4
3
6
5
2