一、二分查找思路分析

1.首先确定该数组中间的下标 ，即mid=(left+high)/2;

2.然后让需要查找的value值与array[mid]值进行比较

2.1)findVal > arr[mid] ,说明你要查找值在mid的右边，因此需要向右递归进行查找。

2.1)findVal < arr[mid] ,说明你要查找值在mid的左边，因此需要向左递归进行查找。

2.3)findVal == arr[mid]说明找到，就返回

二、二分查找递归的退出条件

1.找到就结束递归

2.递归完整个数组，仍然没有找到findVal，也需要结束递归，即left > right 就要退出

三、代码实现

package cn.zzw.algorithm.search;

import java.util.ArrayList;
import java.util.List;

public class BinarySearch {
    
    

    public static void main(String[] args) {
    
    
        int arr[]={
    
    1,8,96,54,65,65,65,35,52,77};
        //int index=binarySearch(arr,0,arr.length-1,8);
        //System.out.println("下标为："+index);

        List<Integer> list=binarySearch2(arr,0,arr.length-1,65);
        System.out.println("下标集合为："+list);
    }

    /**
     *
     * @param arr 所要查找值的数组
     * @param left 数组最左下标
     * @param right 数组的最右下标
     * @param findVal 要查找的值
     * @return
     */
    public static int binarySearch(int[] arr,int left,int right,int findVal)
    {
    
    
        //如果left>right,说明递归查找整个数组之后没有找到相应的数值
        if(left>right)
        {
    
    
            return -1;
        }
        int mid=(left+right)/2;

        if(findVal>arr[mid])
        {
    
    
            return binarySearch(arr,mid+1,right,findVal);
        }
        else if (findVal<arr[mid])
        {
    
    
            return binarySearch(arr,left,mid-1,findVal);
        }
        else
        {
    
    
            return mid;
        }
    }

    /**
     * 在一个数组中含有相同的数值，则如何将所有的下标都找到
     *
     * 思路分析：
     * 1.在找到mid时，不要直接返回
     * 2.向mid索引值的左边扫描，将所有满足的值的下标，加入到集合ArrayList
     * 3.向mid索引值的又边扫描，将所有满足的值的下标，加入到集合ArrayList
     * 4.将ArrayLis返回
     */
    public static ArrayList<Integer> binarySearch2(int[] arr,int left,int right,int findVal)
    {
    
    
        if(left>right)
        {
    
    
            return new ArrayList<Integer>();
        }
        int mid=(left+right)/2;

        if(findVal>arr[mid])
        {
    
    
            return binarySearch2(arr,mid+1,right,findVal);
        }
        else if (findVal<arr[mid])
        {
    
    
            return binarySearch2(arr,left,mid-1,findVal);
        }
        else
        {
    
    
            ArrayList<Integer> arrayList = new ArrayList<>();
            //向mid索引值的左边扫描，将所有满足的值的下标，加入到ArrayList
            int temp=mid-1;
            while (true)
            {
    
    
                if(temp<0 || arr[temp]!=findVal)
                {
    
    
                    break;
                }
                //否则将temp放入到list集合中
                arrayList.add(temp);
                temp--;
            }
            arrayList.add(mid);

            //向mid索引值的右边扫描，将所有满足的值的下标，加入到ArrayList中
            temp=mid+1;
            while (true)
            {
    
    
                if(temp>arr.length-1||arr[temp]!=findVal)
                {
    
    
                    break;
                }
                //否则，将temp放入到ArrayList
                arrayList.add(temp);
                temp++;
            }
            return arrayList;
        }
    }
}