Implementación (Java) y explicación de la búsqueda binaria (Binary Search) - Estructura de datos común

Implementación (Java) y explicación de la búsqueda binaria: estructuras de datos comunes

1. Explica

También conocida como búsqueda binaria, búsqueda logarítmica, es un algoritmo utilizado para encontrar un elemento en una matriz ordenada.

Ejemplo : encontrar un número en una matriz ascendente. Cada vez que se inspecciona el elemento medio (medio) de la parte actual de la matriz, si el elemento medio resulta ser el elemento objetivo (objetivo), la búsqueda finaliza. Si el elemento del medio es más pequeño que el valor buscado, busque en la mitad izquierda de la matriz [izquierda, centro]; si el elemento del medio es mayor que el valor buscado, busque en la mitad derecha de la matriz [medio, derecha].

La búsqueda binaria se puede utilizar para encontrar el valor máximo (mínimo) que satisface una determinada condición.

El caso mínimo posible del valor máximo que satisface ciertas condiciones (minimización máxima), la primera idea es enumerar el [valor máximo] como la respuesta de menor a mayor, y luego juzgar si es legal. Si la respuesta es monótona, puede usar el método de búsqueda binaria para encontrar la respuesta más rápido

Utilice la búsqueda binaria para resolver la condición de [minimización máxima]:

1. La respuesta está dentro de un intervalo fijo.
2. Es más fácil determinar si un valor cumple las condiciones
3. La solución factible satisface una cierta monotonicidad para el intervalo (x cumple las condiciones, entonces x-1 o x+1 también cumple las condiciones)

• Complejidad del tiempo: mejor caso O(1), promedio/peor caso O(log n)

2. Date cuenta

idea de algoritmo

Suponiendo que el valor objetivo está en un intervalo cerrado [l,r], cada vez que la longitud del intervalo se reduce a la mitad, l=miden ese momento , se encuentra el valor objetivo

El intervalo [l,r]se divide en [l,mid-1]y [mid+1,r]; la operación de actualización es r=mid-1ol=mid+1。

package top.alibra.algorithm;

public class Dichotomy {
    
    
    //折半查找（二分法查找）：前提数组有序
    public static int dichotomySearch(int[] nums, int target) {
    
    
        if(nums == null || nums.length == 0){
    
     //判断数组为空
            return -1;
        }
        int l = 0, r = nums.length - 1; //设置左右边界
        while(l <= r){
    
    
            int mid = l + (r-l) / 2; // 等同于mid=(l+r)/2,这种写法是为了防止数组越界,也可以写为(l+r) >>> 1
            if(nums[mid] == target){
    
     //最终target=mid,返回mid
                return mid;
            }else if(nums[mid] < target) {
    
     //目标值在(mid,r]之间
                l = mid + 1;
            }else {
    
      //目标值在[l,mid)之间
                r = mid - 1;
            }
        }
        // 最后判断: l>r 即数组不存在
        return -1;
    }

    //测试
    public static void main(String[] args) {
    
    
        //定义一个属数组
        int[] arr={
    
    1,3,9,11,12,13,17,24,51,86,87,92,99};
        int num = dichotomySearch(arr,17);
        System.out.println(num);
    }


}