二十一、二分查找算法（递归&&非递归）

一、二分查找思路分析

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

非递归代码实现

package cn.zzw.algorithm.binarySearchNoRecursion;

public class binarySearchNoRecursion {

    public static void main(String[] args) {
        int[] arr = {1,3, 8, 10, 11, 67, 100};
        int index=binarySearchNoRecur(arr,10);
        System.out.println("index="+index);
    }

    //编写一个非递归的二分查找
    public static int binarySearchNoRecur(int arr[],int target)
    {
        int left=0;
        int right=arr.length-1;

        while (left<=right)
        {
            int mid=(left+right)/2;
            if (arr[mid]==target)
            {
                return mid;
            }
            else if (arr[mid]<target)
            {
                left=mid+1;
            }
            else
            {
                right=mid-1;
            }
        }
        return -1;
    }

}