Java基础:常见算法(查找算法)

1.基本查找

查找数组中对应元素的索引, 不能忽略重复的元素索引.

public static void main(String[] args) {
        int[] arr = {1,2,3,4,5,2,5};
        int num = 2;
        ArrayList<Integer> integerArrayList = searchIndex(arr, num);
        System.out.println(integerArrayList);
    }

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

2.二分查找

查找的数组必须是有序排列的

public static void main(String[] args) {
        // array must be ordered
        int[] arr = {7,23,79,81,103,127,131,147};
        int num = 150;
        int i = searchIndex(arr, num);
        System.out.println(i);
    }

    private static int searchIndex(int[] arr, int num) {
        int minIndex = 0;
        int maxIndex = arr.length - 1;
        int midIndex = 0;
        if (arr[minIndex] == num){
            return minIndex;
        } else if (arr[maxIndex] == num) {
            return maxIndex;
        }
        while (minIndex < maxIndex) {
            midIndex = (minIndex + maxIndex) / 2;
            if (arr[midIndex] < num){
                minIndex = midIndex + 1;
                continue;
            } else if (arr[midIndex] > num) {
                maxIndex = midIndex - 1;
                continue;
            }else {
                return midIndex;
            }
        }
        return -1;
    }

总结

3.插值查找

4.斐波那契查找

 5.分块查找

扫描二维码关注公众号，回复： 15136118 查看本文章

分块查找的原理:

就是将一大串数据分为几小串, 然后通过判断查找数字的大小来判断出在第几块中, 再进行基本查找就行. 就是节约了整体查找的时间. 

// 拓展的分块查找
public static void main(String[] args) {
        int[] arr = {27,22,30,40,36,
                    13,19,16,20,
                    7,10,
                    43,50,48};
        int num = 48;
        Block block1 = new Block(22,40,0,4);
        Block block2 = new Block(13,20,5,8);
        Block block3 = new Block(7,10,9,10);
        Block block4 = new Block(43,50,11,13);
        Block[] arrblock = {block1, block2, block3, block4};

        int index = getIndex(arr, num, arrblock);
        System.out.println(index);
    }

    private static int getIndex(int[] arr, int num, Block[] arrblock) {
        int blockIndex = whichBlock(num, arrblock);
        for (int i = arrblock[blockIndex].getStartIndex(); i <= arrblock[blockIndex].getEndIndex(); i++) {
            if (num == arr[i]){
                return i;
            }
        }
        return -1;
    }

    private static int whichBlock(int num, Block[] arrblock) {
        for (int i = 0; i < arrblock.length; i++) {
            if (num >= arrblock[i].getMin() && num <= arrblock[i].getMax()){
                return i;
            }
        }
        return -1;
    }