二分法查找 List / 数组

查找第一个大于等于给定值的元素索引（ List

package com.fyh.meng.gameserver.util;

import java.lang.reflect.Method;
import java.util.List;

/**
 * TODO 构建一个搜索工具类
 * 
 * @author wangsong
 * @date 2019年9月16日
 */
public class BinarySearch {

	/**
	 * TODO 二分法查找
	 * 查找第一个大于等于给定值的元素索引 

	 * 
	 * @date 2019年9月16日
	 * @param a         ： 对象集合,必须根据给定值/权重值排序的，并且不含重复元素的 

	 * @param x         :  给定值，权重值 

	 * @param searchKey ： 获取给定值/权重值的get方法名，目的是通过反射获取属性值 

	 * @return 索引，找不到返回0  

	 * 排序示例： a.sort((x, y) ->Integer.valueOf(x.getSearchKey()).compareTo(Integer.valueOf(y.getSearchKey())));
	 */
	public static  int Big(List a, int x, String searchKey) {
		try {
			int low = 0;
			int high = a.size() - 1;
			while (low <= high) {
				// 获得折半值,mid小于1,直接返回0（当只有一条数据，mid百分之百等于0）
				int mid = low + ((high - low) >> 1);
				if(mid < 1) {
					return 0;
				}
				// 通过反射获取T排序属性对应的给定值
				T mt = a.get(mid);
				Method method = mt.getClass().getMethod(searchKey);
				int weight = (int) method.invoke(mt);
				//判断给点值
				if (weight >= x) {
					// 通过反射获取T排序属性对应的给定值
					T mt2 = a.get(mid - 1);
					Method method2 = mt2.getClass().getMethod(searchKey);
					int weight2 = (int) method2.invoke(mt2);
					// 在找到符合要求的前提下，提前mid值
					if ((mid == low) || weight2 < x)
						return mid;
					else {
						high = mid - 1;
					}
				} else {
					low = mid + 1;
				}
			}
		} catch (Exception e) {
			// TODO: handle exception
			e.printStackTrace();
		}
		return 0;
	}
}

参考使用方法

//最大权重值
int maxWegiht = ？;

// 根据最大权重值 获得 随机权重值
int weight = (int) (Math.random() * maxWegiht) + 1;

// 根据随机权重,二分法找到随机物品的的索引（list ）
int index = BinarySearch.Big(list, weight, "getPosWeight");

//获得随机物品
list.get(index);

二、java二分法查询实现 （数组）

用递归和非递归2种方法实现二分法
四种常见的二分查找变形问题
如何编程实现“求一个数的平方根”？要求精确到小数点后6位？
总结
用递归和非递归2种方法实现二分法
1）非递归实现

//在数组a（有序的并且不含重复元素）中查找x，用二分查找，非递归的实现
//n表示数组a中的元素个数
//找到返回元素在数组中的下标，找不到返回-1
  public static int binary_search(int[] a,int n,int x){
    int low=0;
    int high=n-1;
    while(low<=high){
        int mid=low+((high-low)>>1);
        if(a[mid]>x){
            high=mid-1;
        }else if (a[mid]

2）递归实现

//在数组a（有序的并且不含重复元素）中查找x，用二分查找
//low表示数组a的左端点，high表示右端点
//找到返回元素在数组中的下标，找不到返回-1
    public static int binary_search(int[] a,int low,int high,int value){
    if(low>high) return -1;
    int mid=low+((high-low)>>1);
    if(a[mid]==value){
        return mid;
    }else if (a[mid]

三、四种常见的二分查找变形问题

1）查找第一个值等于给定值的元素

 public static int binary_search(int[] a,int n,int x){
    int low=0;
    int high=n-1;
    while(low<=high){
        int mid=low+((high-low)>>1);
        if(a[mid]>x){
            high=mid-1;
        }else if (a[mid]

2）查找最后一个值等于给定值的元素

public static int binary_search(int[] a,int n,int x){
    int low=0;
    int high=n-1;
    while(low<=high){
        int mid=low+((high-low)>>1);
        if(a[mid]>x){
            high=mid-1;
        }else if (a[mid]

3）查找第一个大于等于给定值的元素

 public static int binary_search(int[] a,int n,int x){
    int low=0;
    int high=n-1;
    while(low<=high){
        int mid=low+((high-low)>>1);
        if(a[mid]>=x){
        //在找到符合要求的前提下，提前mid值
           if((mid==low)||(a[mid-1]

4）查找最后一个小于等于给定值的元素

 public static int binary_search(int[] a,int n,int x){
    int low=0;
    int high=n-1;
    while(low<=high){
        int mid=low+((high-low)>>1);
        if(a[mid]>x){
            high=mid-1;
        }else {
         //在找到符合要求的前提下，滞后mid值
            if((mid==n-1)||(a[mid+1]>x)) return mid;
else low=mid+1;
        }
    }
    return -1;
}

如何编程实现“求一个数的平方根”？要求精确到小数点后6位？
思想：牛顿迭代法求平方根
参考：百度百科

		//输入一个值
		Scanner sc = new Scanner(System.in);
		int a = sc.nextInt();
		float temp=1;
		while(Math.abs(temp-a/temp)>1e-6)
		{	
			temp=(temp+a/temp)/2;
		}		
		System.out.println(temp);