Java-Grundlagen: Gängige Algorithmen (Suchalgorithmen)

1. Einfache Suche

Suchen Sie den Index des entsprechenden Elements im Array. Doppelte Elementindizes können nicht ignoriert werden.

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. Binäre Suche

Das durchsuchte Array muss sortiert sein

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

Zusammenfassen

3. Interpolationssuche

4. Fibonacci-Fund

 5. Blocksuche

Das Prinzip der Satzsuche:

Es besteht darin, eine große Datenzeichenfolge in mehrere kleine Zeichenfolgen aufzuteilen und dann anhand der Größe der gesuchten Zahl zu bestimmen, welcher Block sich darin befindet, und anschließend eine einfache Suche durchzuführen. Dies spart insgesamt Suchzeit. 

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