Java中五种常见的查找方式

1.基本查找
 

也叫做顺序查找顺序查找也称为线形查找，属于无序查找算法。从数据结构线的一端开始，顺序扫描，依次将遍历到的结点与要查找的值相比较，若相等则表示查找成功；若遍历结束仍没有找到相同的，表示查找失败   

说明：顺序查找适合于存储结构为数组或者链表。

package date11;

import java.util.ArrayList;

public class text1 {
    public static void main(String[] args) {

        int[] arr={12,34,32,56,78,23,34,56,67};
        int num=34;
        System.out.println(fangno(arr,num));
    }

    private static ArrayList fangno(int[] arr, int num) {
        ArrayList<Integer> list = new ArrayList<>();
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] == num) {
                list.add(i);
            }

        }

        return list;
    }}

2.二分查找

也叫做折半查找

说明：元素必须是有序的，从小到大，或者从大到小都是可以的。
如果是无序的，也可以先进行排序。但是排序之后，会改变原有数据的顺序，查找出来元素位置跟原来的元素可能是不一样的，所以排序之后再查找只能判断当前数据是否在容器当中，返回的索引无实际的意义

1.二分查找的优势?
提前查找效率
2.二分查找的前提条件?
数据必须是有序的
如果数据是乱的，先排序再用二分查找得到的索引没有实际意义，只能确定当
前数字在数组中是否存在，因为排序之后数字的位置就可能发生变化了
3.二分查找的过程
min和max表示当前要查找的范围
mid是在min和max中间的
如果要查找的元素在mid的左边，缩小范围时，min不变，max等于micX
如果要查找的元素在mid的右边，缩小范围时，max不变，min等于mid加T

package date11;

public class text2 {
    public static void main(String[] args) {
        int[] arr={12,17,26,29,31,38,45,49,53,58,65,69,76,79,82,88,91,99};
        int num=91;
        System.out.println(dd(arr,num));
    }

    public static int dd(int[] arr, int num) {
        int min = 0, max = arr.length - 1;
        while (true) {
            if (min > max) {
               return  -1;
            }
            int mid = (min + max) / 2;
            if(arr[mid]>num){
                max=mid-1;
            }else if(arr[mid]<num){
                min=mid+1;
            }else {
                return mid;
            }


        }
    }
}

3. 插值查找

在介绍插值查找之前，先考虑一个问题： ​ 为什么二分查找算法一定要是折半，而不是折四分之一或者折更多呢？ 其实就是因为方便，简单，但是如果我能在二分查找的基础上，让中间的mid点，尽可能靠近想要查找的元素，那不就能提高查找的效率了吗？ 二分查找中查找点计算如下： 　　mid=(min+max)/2, 即mid=min+1/2*(max-min); 我们可以将查找的点改进为如下： 　　mid=min+(num-a[min])/(a[max]-a[min])*(max-min)， 这样，让mid值的变化更靠近关键字num，这样也就间接地减少了比较次数。 　　

基本思想：基于二分查找算法，将查找点的选择改进为自适应选择，可以提高查找效率。当然，差值查找也属于有序查找。 **细节：**对于表长较大，而关键字分布又比较均匀的查找表来说，插值查找算法的平均性能比折半查找要好的多。反之，数组中如果分布非常不均匀，那么插值查找未必是很合适的选择。 代码跟二分查找类似，只要修改一下mid的计算方式即可。

4. 斐波那契查找

介绍斐波那契查找算法之前，我们先介绍一下很它紧密相连并且大家都熟知的一个概念——黄金分割。

　　黄金比例又称黄金分割，是指事物各部分间一定的数学比例关系，即将整体一分为二，较大部分与较小部分之比等于整体与较大部分之比，其比值约为1:0.618或1.618:1。

　　0.618被公认为最具有审美意义的比例数字，这个数值的作用不仅仅体现在诸如绘画、雕塑、音乐、建筑等艺术领域，而且在管理、工程设计等方面也有着不可忽视的作用。因此被称为黄金分割。

　　在数学中有一个非常有名的数学规律：斐波那契数列：1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89…….

（从第三个数开始，后边每一个数都是前两个数的和）。

然后我们会发现，随着斐波那契数列的递增，前后两个数的比值会越来越接近0.618，利用这个特性，我们就可以将黄金比例运用到查找技术中

基本思想：也是二分查找的一种提升算法，通过运用黄金比例的概念在数列中选择查找点进行查找，提高查找效率。同样地，斐波那契查找也属于一种有序查找算法。斐波那契查找也是在二分查找的基础上进行了优化，优化中间点mid的计算方式即可

二分查找、插值查找，斐波那契额查询各自的特点相同点：
都是通过不断的缩小范围来查找对应的数据的不同点：
计算mid的方式不一样
二分查找：mid每次都是指向范围的中间位置
插值查找：mid尽可能的靠近要查找的数据，但是要求数据尽可能的分布均匀
斐波那契额查找：根据黄金分割点来计算mid指向的位置

5.分块查找

分块的原则1：前一块中的最大数据，小于后一块中所有的数据（块内无序，块间有序）
分块的原则2：块数数量一般等于数字的个数开根号。比如：16个数字一般分为4块左右。
核心思路：先确定要查找的元素在哪一块，然后在块内挨个查找。

分块查找 

当数据表中的数据元素很多时，可以采用分块查找。汲取了顺序查找和折半查找各自的优点，既有动态结构，又适于快速查找分块查找适用于数据较多，但是数据不会发生变化的情况，如果需要一边添加一边查找，建议使用哈希查找

分块查找的过程：

1. 需要把数据分成N多小块，块与块之间不能有数据重复的交集。
2. 给每一块创建对象单独存储到数组当中
3. 查找数据的时候，先在数组查，当前数据属于哪一块
4. 再到这一块中顺序查找

package date11;

public class text3 {
    public static void main(String[] args) {
        int[] arr={12,13,18,20,23,22,27,30,36,33,31,39,40,49,43,56,60};
        int num=18;
        Block d1=new Block(20,0,3);
        Block d2=new Block(30,4,7);
        Block d3=new Block(40,8,12);
        Block d4=new Block(60,13,16);
        Block[] blo={d1,d2,d3,d4};
        int dax = dax(arr, blo, num);
        System.out.println(dax);


    }
    public static int dax(int[] arr, Block[] blo  , int num){
        int e = ee(blo, num);
        if(e==-1){
            return  -1;
        }
        int indexindx = blo[e].indexindx;
        int endindx = blo[e].endindx;
        for (int i =indexindx; i < endindx; i++) {
           if(arr[i]==num){
               return i;
           }
        }

        return -1;
    }
    public static int ee(Block[] blo, int num){
        for (int i = 0; i < blo.length; i++) {
            if(num<blo[i].getMax()){
                return i;
            }

        } return -1;
    }

    static class Block{
        private int max;
        private int indexindx;
        private int endindx;


        public Block() {
        }

        public Block(int max, int indexindx, int endindx) {
            this.max = max;
            this.indexindx = indexindx;
            this.endindx = endindx;
        }

        /**
         * 获取
         * @return max
         */
        public int getMax() {
            return max;
        }

        /**
         * 设置
         * @param max
         */
        public void setMax(int max) {
            this.max = max;
        }

        /**
         * 获取
         * @return indexindx
         */
        public int getIndexindx() {
            return indexindx;
        }

        /**
         * 设置
         * @param indexindx
         */
        public void setIndexindx(int indexindx) {
            this.indexindx = indexindx;
        }

        /**
         * 获取
         * @return endindx
         */
        public int getEndindx() {
            return endindx;
        }

        /**
         * 设置
         * @param endindx
         */
        public void setEndindx(int endindx) {
            this.endindx = endindx;
        }

        public String toString() {
            return "denm{max = " + max + ", indexindx = " + indexindx + ", endindx = " + endindx + "}";
        }
    }
}