Algoritmo: algoritmo de búsqueda estática

Encontrar es el algoritmo más simple. Pero el algoritmo de búsqueda es diferente, habrá diferentes lagunas.

1. Busca en orden con centinelas.
Es muy simple, déjame comenzar el código:

int[] a = new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
public static int findKey(int[] a, int key) {
	int index = a.length;
	while(index -- > 0) {
		if(a[index] == key)
			return index;
	}
	return -1;
}

Hacer esto es hacer dos juicios (uno while loop y otro if instrucción) Si hay un centinela, podemos salvar un juicio. Por lo general, colocamos el centinela en la posición 0 en la matriz.
La estructura de la matriz y la función de búsqueda han cambiado de la siguiente manera:

int key = 5;
int[] a = new int[] { key, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
public static int findKey(int[] a, int key) {
	int index = a.length - 1;
	while (a[index --] == key) {
		return index;
	}
	return 0;
}

En este caso, si el resultado de findKey devuelve 0, significa que la búsqueda falló, es decir, no hay una posición de valor clave en la matriz a.

2. Búsqueda binaria La búsqueda
binaria se basa en el orden de la matriz, es decir, de mayor a menor o de menor a mayor. Entonces el contenido de la matriz es 1 2 3 4 5 6 7 8 9 y la posición donde se encuentra key = 8. Podemos ver la implementación del algoritmo:

public static int findKey(int[] a, int key) {
	int low = 0;
	int high = a.length - 1;
	int middle;
	while (low <= high) {
		middle = (low + high) / 2;
		if (a[middle] == key)
			return middle;
		else if (key < a[middle])
			high = middle - 1;
		else
			low = middle + 1;
	}
	return -1;
}

En otras palabras, si desea encontrar 8, bajo = 0, alto = 8, medio = (8 + 0) / 2 = 4. Debido a que una tecla [central] <, bloqueamos 4-8 y la doblamos por la mitad nuevamente.
También dije al principio que el algoritmo de búsqueda binaria se basa en el orden de la matriz, pero la eficiencia de búsqueda será alta de esta manera. En términos generales, cuando se trata de reducir a la mitad y recursividad, la eficiencia es O (log2N).

3. Búsqueda de bloques La búsqueda de
bloques es similar a una combinación de búsqueda secuencial y búsqueda binaria.
La matriz buscada está ordenada por clave y cada nodo contiene el campo clave más grande y un puntero al primer nodo del bloque.
La estructura es la siguiente:

class Indetype {
	int max; // 块间最大值
	int start; // 块的起始位置
}

Primero, necesitas encontrar el valor máximo entre bloques.
El tamaño de cada grupo es arbitrario. Para una mejor demostración, establezco el tamaño de cada grupo en 7. Y para asegurarse de que el valor mínimo del bloque actual sea mayor que el valor máximo del bloque anterior.
Primero, cree una tabla de índice:

class IndexType {
	int max; // 块内最大值
	int start; // 块内开始位置
}

public static int findKey(int[] a, int key) {
	int pieceCount = 0; // 计算块个数
	if (a.length % 7 == 0)
		pieceCount = a.length / 7;
	else
		pieceCount = a.length / 7 + 1;

	IndexType[] indexType = new IndexType[pieceCount]; // 初始化块数据
	for (int i = 0; i < pieceCount; i++) {
		indexType[i] = new IndexType();
		indexType[i].start = 7 * i;
	}

	for (int i = 0; i < pieceCount - 1; i++) { // 找到前pieceCount - 1块的最大值
		int max = indexType[i].start;
		for (int j = indexType[i].start; j < indexType[i + 1].start; j++) {
			if (max < a[j])
				max = a[j];
		}
		indexType[i].max = max;
	}

	int max = indexType[pieceCount - 1].start; // 找到最后一块的最大值
	for (int i = indexType[pieceCount - 1].start; i < a.length; i++) {
		if (max < a[i])
			max = a[i];
	}
	indexType[pieceCount - 1].max = max;
	
	if(key > indexType[pieceCount-1].max) // 如果大于最后一块的最大值，就返回-1
		return -1;

	// 找到key所在的块内范围，采用顺序查找
	int index = 0;
	for (index = 0; index < pieceCount - 1; index++) {
		if (indexType[index].max >= key)
			break;
	}
		
	//找到块内具体的位置,采用顺序查找
	int low = 0;
	int high = 0;
	if (index == pieceCount-1) {
		low = indexType[index].start;
		high = a.length;
	}
	else {
		low = indexType[index].start;
		high = indexType[index +1].start;
	}
	for(int i = low; i < high; i ++) {
		if(a[i] == key)
			return i;
	}
	return -1;
}

Llame a la función anterior:

int a[] = new int[] { 22, 12, 13, 8, 9, 20, 33,
	42, 44, 39, 24, 48, 60, 58,
	74, 57, 86, 53, 91, 95, 97,
	100, 98, 101
};
int key = 20;
int position = findKey(a, key);
System.out.println(position);