Java Basics: Common Algorithms (Search Algorithms)

1. Basic search

Find the index of the corresponding element in the array, duplicate element indices cannot be ignored.

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. Binary search

The searched array must be sorted

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;
    }

Summarize

3. Interpolation lookup

4. Fibonacci Find

 5. Block search

The principle of block search:

It is to divide a large string of data into several small strings, and then determine which block is in by judging the size of the searched number, and then perform a basic search. It saves the overall search time. 

// 拓展的分块查找
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;
    }