Java常见算法之查找算法

目录

基本查找

二分查找/折半查找

分块查找

---

基本查找

也叫做顺序查找

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

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

public class BasicSearchDemo1 {
    public static void main(String[] args) {
        //基本查找/顺序查找
        int[] arr = {131, 127, 147, 81, 103, 23, 7, 79};
        int number = 103;
        System.out.println(basicSearch(arr, number));
    }


    public static boolean basicSearch(int[] arr, int number) {
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] == number) {
                return true;
            }
        }
        return false;
    }
}

二分查找/折半查找

说明：元素必须是有序的，从小到大，或者从大到小都是可以的。

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

　　基本思想：也称为是折半查找，属于有序查找算法。用给定值先与中间结点比较。比较完之后有三种情况：

• 相等

  说明找到了

• 要查找的数据比中间节点小

  说明要查找的数字在中间节点左边

• 要查找的数据比中间节点大

  说明要查找的数字在中间节点右边

public class BasicSearchDemo2 {
    public static void main(String[] args) {
        //二分查找/折半查找
        int[] arr = {7, 23, 79, 81, 103, 127, 131, 147};
        System.out.println(basicSearch(arr, 79));
    }

    public static int basicSearch(int[] arr, int number) {
        int min = 0;
        int max = arr.length - 1;
        while (true) {
            if (min > max) {
                return -1;
            }
            int mid = (min + max) / 2;
            //number在mid的左边min不变，max减1
            if (arr[mid] > number) {
                max -= 1;
                number在mid的右边max不变，min减1
            } else if (arr[mid] < number) {
                min -= 1;
            } else {
                return mid;
            }
        }
    }
}

分块查找

当数据表中的数据元素很多时，可以采用分块查找。

汲取了顺序查找和折半查找各自的优点，既有动态结构，又适于快速查找

分块查找适用于数据较多，但是数据不会发生变化的情况，如果需要一边添加一边查找，建议使用哈希查找

分块查找的过程：

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

public class BasicSearchDemo3 {
    public static void main(String[] args) {
        int[] arr = {16, 5, 9, 12, 21, 18,
                32, 23, 37, 26, 45, 34,
                50, 48, 61, 52, 73, 66};

        Block b1 = new Block(21, 0, 5);
        Block b2 = new Block(45, 6, 11);
        Block b3 = new Block(73, 12, 17);

        Block[] blocksArr = {b1, b2, b3};
        int number = 61;

        int index = getIndex(blocksArr, arr, number);
        System.out.println(index);
    }

    private static int getIndex(Block[] blockArr, int[] arr, int number) {
        int indexBlock = findIndexBlock(blockArr, number);
        if (indexBlock == -1) {
            return -1;
        }
        int startIndex = blockArr[indexBlock].getStartIndex();
        int ensIndex = blockArr[indexBlock].getEndIndex();
        for (int i = startIndex; i <= ensIndex; i++) {
            if (arr[i] == number) {
                return i;
            }
        }
        return -1;
    }

    public static int findIndexBlock(Block[] blockArr, int number) {
        for (int i = 0; i < blockArr.length; i++) {
            if (blockArr[i].getMax() >= number) {
                return i;
            }
        }
        return -1;
    }
}

class Block {
    private int max;//块内最大值
    private int startIndex;//块内起始索引
    private int endIndex; //块内结束索引

    public Block() {
    }

    public int getMax() {
        return max;
    }

    public void setMax(int max) {
        this.max = max;
    }

    public int getStartIndex() {
        return startIndex;
    }

    public void setStartIndex(int startIndex) {
        this.startIndex = startIndex;
    }

    public int getEndIndex() {
        return endIndex;
    }

    public void setEndIndex(int endIndex) {
        this.endIndex = endIndex;
    }

    public Block(int max, int startIndex, int endIndex) {
        this.max = max;
        this.startIndex = startIndex;
        this.endIndex = endIndex;
    }

    @Override
    public String toString() {
        return "Block{" +
                "max=" + max +
                ", startIndex=" + startIndex +
                ", endIndex=" + endIndex +
                '}';
    }
}