二分查找算法（递归与非递归）_二分查找递归和非递归

二份查找算法（递归与非递归）

用此算法的前提是该研究对象是有序数组

一、非递归

思路分析：

1. 实现确定该数组的中间的下标

2. 然后让需要查找的数findVal和arr[mid]比较

   2.1 findVal>arr[mid]，说明你要查找的数在mid的右边，因此需要递归向右查找

   2.2 findVal<arr[mid],说明你查找的数在mid的左边，因此需要递归向左查找

   2.3 finfVal==arr[mid]，就返回

什么时候结束：

1. 找到就结束递归

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

代码实现：

package 基础算法.二分查找算法;

public class BinarySearch {
    public static void main(String[] args) {
        int arr[] = {1,8,10,89,1000,1234};
        int resIndex = binarySearch(arr,0,arr.length-1,1234);
        System.out.println(resIndex);
    }
    //二分算法（递归)

    /**
     *
     * @param arr
     * @param left
     * @param right
     * @param findVal
     * @return 如果找到就返回下标，没有找到就返回-1
     */
    public static int binarySearch(int[] arr,int left,int right,int findVal){
        
        //当left>right时，结束递归
        if (left > right){
            return -1;
        }
        int mid =(left+right)/2;
        int midVal = arr[mid];

        if(findVal > midVal){//向右递归
            return binarySearch(arr, mid+1, right, findVal);
        }
        else if (findVal < midVal){//向左递归
            return  binarySearch(arr, left, mid-1, findVal);
        }
        else {
            return mid;
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

上述代码存在没有考虑findVal对应arr数组中的两个或者多个，只会现实出现的第一个

改进思路分析：

1. 在找的mid索引值,不要立马返回
2. 向mid索引值得左边扫描，将所有满足的值的元素下标加到集合ArrayList
3. 向mid索引的右边扫描，将满足的所有的值的下标，加入到集合ArrayList
4. 将ArrayList返回

改进代码：

package 基础算法.二分查找算法;

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

public class BinarySearch {
    public static void main(String[] args) {
        int arr[] = {1,8,10,89,1000,1000,1000,500,1000,1234};
        List<Integer> resIndexList =binarySearch2(arr,0,arr.length-1,1000);
        System.out.println("resIndexList="+resIndexList);
    }
    //二分查找（递归改进）
    /**
     *
     * @param arr 数组
     * @param left 左边索引
     * @param right 右边索引
     * @param findVal 找的值
     * @return 如果找到返回ArrayList集合，没有找到返回[]
     */
    public static ArrayList<Integer> binarySearch2(int[] arr, int left, int right, int findVal){

        //当left>right时，结束递归
        if (left > right){
            return new ArrayList<Integer>();
        }
        int mid =(left+right)/2;
        int midVal = arr[mid];

        if(findVal > midVal){//向右递归
            return binarySearch2(arr, mid+1, right, findVal);
        }
        else if (findVal < midVal){//向左递归
            return  binarySearch2(arr, left, mid-1, findVal);
        }
        else {
            /*1. 在找的mid索引值,不要立马返回
            2. 向mid索引值得左边扫描，将所有满足的值的元素下标加到集合ArrayList
            3. 向mid索引的右边扫描，将满足的所有的值的下标，加入到集合ArrayList
            4. 将ArrayList返回*/

            ArrayList<Integer> resIndexlist = new ArrayList<Integer>();
            //向mid索引值左边扫描，将满足的所有值得元素下标，加入集合ArrayList
            int temp = mid -1;
            while(true){
                if (temp<0){//退出
                    break;
                } 
                //如果找到temp放入到resIndexlist
                if (arr[temp]==findVal){
                    resIndexlist.add(temp);
                }
                temp -=1;//temp左移
            }
            //把找的值添加到ArrayList中去
            resIndexlist.add(mid);
            //向mid索引值右边扫描，将满足的所有值得元素下标，加入集合ArrayList
             temp = mid +1;
            while(true){
                if (temp>arr.length-1){//退出
                    break;
                } 
                //如果找到temp放入到resIndexlist
                if (arr[temp]==findVal){
                    resIndexlist.add(temp);
                }
               
                temp +=1;//temp右移
            }
            return resIndexlist;
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73

结果：

resIndexList=[4, 5, 6, 8]

二、递归

思路分析：

• 找的数比我中间的要小，则向左边查找，找的数比我中间的数要大则向右边查找（前提是升序）
• 不断的重复第一步直至中间值就是自己

代码实现：

package 基础算法.二分查找算法;

public class BinarySearchNoRecur {
    public static void main(String[] args) {
        int [] arr ={1,3,8,10,11,67,100};
        int index = binarySearch(arr,-8);
        System.out.println("index="+index);
    }
    //二分算法的非递归
    /**
     *
     * @param arr
     * @param target
     * @return 返回对应的下标，-1表示没有找到
     */
    public static int binarySearch(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){
                right =mid - 1;//需要向左边查找
            }
            else {
                left = mid +1;//需要向右边查找
            }
        }
        return -1;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35