java数据结构和算法——二分查找算法

一、二分查找算法的介绍

• 二分查找又称为折半查找
• 假设表中元素是按升序排列（必须是有序列表），将表中间位置记录的关键字与查找关键字比较
• 如果两者相等，则查找成功；否则利用中间位置记录将表分成前、后两个子表，如果中间位置记录的关键字大于查找关键字则进一步查找前一子表；否则进一步查找后一子表。
• 重复以上过程，直到找到满足条件的记录，使查找成功，或直到子表不存在为止，此时查找不成功。

二、二分查找算法的思路分析

三、二分查找算法的示例需求1（数组中的数值都不相同）

请对一个有序数组进行二分查找 {1,8, 10, 89, 1000, 1234} ，输入一个数看看该数组是否存在此数，并且求出下标，如果没有就提示"没有这个数"。

四、二分查找算法的示例需求1演示

1、代码

package com.rf.springboot01.dataStructure.search;

/**
 * @description: 二分查找算法示例 有序数组中元素没有重复的情况
 *                1、使用二分查找的前提是：该数组是有序的.
 * @author: xiaozhi
 * @create: 2020-08-13 23:10
 */
public class BinarySearch {
    public static void main(String[] args) {
        //有序数组中元素没有重复的情况
        int[] arr ={1, 8, 10, 89,1000,1234 };
        int index=binarySearch(arr,0,arr.length-1,8);
        System.out.println("指定数组元素8的下标为======="+index);
        int index1=binarySearch(arr,0,arr.length-1,1234);
        System.out.println("指定数组元素1234的下标为======="+index1);
        int index2=binarySearch(arr,0,arr.length-1,6);
        System.out.println("指定数组元素6的下标为======="+index2);
    }


    /** 
    * @Description:  二分查找算法示例方法
    * @Param:  arr   数组
     *          left  左边的索引
     *          right 右边的索引
     *          findValue 要查找的值
    * @Author: xz  
    * @return: List
    * @Date: 2020/8/13 23:13  
    */ 
    public static int binarySearch(int[] arr, int left, int right, int findValue){
        // 当 left > right 时，说明递归整个数组，但是没有找到
        if(left > right){
            return -1;
        }
        int mid =(left + right) / 2;//获取数组中间的索引
        int midValue=arr[mid]; //获取数组中间索引的值
        if(findValue<midValue){ // 向左递归
            return  binarySearch(arr,left,mid-1,findValue);
        }else if(findValue>midValue){// 向右递归
            return binarySearch(arr,mid+1,right,findValue);
        }else{
           return mid;
        }
    }
}

2、运行main函数，测试结果如下

五、二分查找算法的示例需求2（数组中有多个相同的数值时）

{1,8, 10, 89, 1000, 1000，1234} 当一个有序数组中，有多个相同的数值时，如何将所有的数值都查找到，比如这里的 1000.

六、二分查找算法的示例需求2演示

1、代码

package com.rf.springboot01.dataStructure.search;

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

/**
 * @description: 二分查找算法完整示例 数组元素中有多个相同的数值
 * @author: xiaozhi
 * @create: 2020-08-13 23:33
 */
public class BinarySearch2 {
    public static void main(String[] args) {
        //序数组中有多个相同的数值时
        int[] arr ={1, 8, 10, 89,1000,1000,1234};
        List<Integer> indexList=binarySearch2(arr,0,arr.length-1,1000);
        System.out.println("指定数组元素1000的下标为"+indexList);
    }
    /** 
    * @Description: 二分查找算法完整示例方法
    * @Param:  arr   数组
    *          left  左边的索引
    *          right 右边的索引
    *          findValue 要查找的值
    * @Author: xz  
    * @return: void
    * @Date: 2020/8/14 22:24  
    */ 
    public static List<Integer> binarySearch2(int[] arr,int left,int right,int findValue){
        // 当 left > right 时，说明递归整个数组，但是没有找到
        if(left > right){
            return new ArrayList<>();
        }
        int mid =(left + right) / 2;//获取数组中间的索引
        int midValue=arr[mid]; //获取数组中间索引的值
        if(findValue<midValue){ // 向左递归
            return  binarySearch2(arr,left,mid-1,findValue);
        }else if(findValue>midValue){// 向右递归
            return binarySearch2(arr,mid+1,right,findValue);
        }else{
            /**
             * 思路分析
             * 1. 在找到mid 索引值，不要马上返回
             * 2. 向mid 索引值的左边扫描，将所有满足 1000， 的元素的下标，加入到集合ArrayList
             * 3. 向mid 索引值的右边扫描，将所有满足 1000， 的元素的下标，加入到集合ArrayList
             * 4. 将Arraylist返回
             */
            List<Integer> indexlist = new ArrayList<>();
            //向mid 索引值的左边扫描，将所有满足1000的元素的下标，加入到集合List
            int temp =mid-1;
            while(true){
                if(temp < 0 || arr[temp] != findValue){//退出
                    break;
                }
                //否则，就temp 放入到 indexlist
                indexlist.add(temp);
                temp -= 1;//temp左移
            }
            indexlist.add(mid);

            //向mid 索引值的右边扫描，将所有满足1000的元素的下标，加入到集合List
            temp =mid+1;
            while(true){
                if(temp > arr.length-1 || arr[temp] != findValue){//退出
                    break;
                }
                //否则，就temp 放入到 indexlist
                indexlist.add(temp);
                temp += 1;//temp右移
            }
            return indexlist;
        }
    }

}

2、运行main函数，测试结果如下