En primer lugar, el algoritmo de búsqueda de matriz lineal.
Conclusión: Como su nombre indica, es lo que usted quiere encontrar un elemento de la matriz para ver si en la matriz.
Encontrar el principio de lineal: búsqueda lineal es la forma más básica de encontrarlo es comparar los diversos elementos de los elementos objetivo y una serie de generales que quieren entrar, que para encontrar el elemento de destino para el éxito, de lo contrario no se encuentra.
Vamos a escribir una implementación del método de búsqueda de la red lineal utilizando el lenguaje Java:
//定义线性查找的方法，参数为目标元素
public static void LineSearch(int target){
//定义目标数组arr，并初始化
int[] arr = new int[] {1,8,10,6,30,5,12,23};
//定义目标元素的下标，初始为-1
int index=-1;
/*进行for循环，将数组中的元素与目标元素对比，如存在，则返回目标元素在
* 数组中的下标，若不存在，则返回初始下标-1
*/
for(int i=0; i<arr.length; i++) {
if(arr[i]==target) {
index = i;
break; //终止当前循环
}
}
System.out.println("线性查找算法的目标元素在数组中的下标为:"+index);
}Este código es se implementa un método de búsqueda lineal, si el elemento de destino en la matriz, la salida del elemento de destino en los subíndices de matriz, mientras que la salida de -1.
Para ejecutar el método en Java, es necesario llamar a este método en el método principal, aquí está el código completo.
En segundo lugar, el algoritmo de búsqueda de matriz binaria.
Binarios funciona el algoritmo de búsqueda: en primer lugar para asegurarse de que los datos de la matriz se ordenan (el valor por defecto es de pequeño a gran pedido), encontrar el elemento de destino en los datos ordenados, aspecto para el algoritmo lineal anterior para cada relación en comparación con la eficiencia mucho más rápido. Hay que señalar que la premisa es ordenada de datos, si no ordenada de datos, no se puede utilizar el algoritmo de búsqueda binaria.
//定义二分查找的方法，参数为目标元素
public static void BinarySearch(int target) {
//定义目标数组newArr,并初始化，注意，二分查找的前提是：一组数是按从小到大排列的
int[] newArr = new int[] {1,2,3,4,5,6,7,8,9};
//定义目标元素的下标，初始为-1
int index = -1;
//记录数组的开始位置
int begin = 0;
//记录数组的结束位置
int end = newArr.length-1;
//记录数组的中间位置
int mid = (begin+end)/2;
//循环查找
while(true) {
//上开始位置在结束位置之后或重合，此时还没查找到目标元素，则代表数组中没有该元素，返回-1
if(begin>=end) {
return -1;
}
//判断中间的这个元素是否是要查找的元素
if(newArr[mid]==target) {
index=mid;
break;
//中间这个元素不是要查找的元素
}else {
//如果中间这个元素比目标元素大
if(newArr[mid]>target) {
end = mid-1; //把结束位置调整到中间位置的前一个元素
}else {
begin = mid+1; //把开始位置调整到中间位置的后一个元素
}
//确定新的中间元素
mid = (begin+end)/2;
}
}
System.out.println("二分查找算法的目标元素的下标为:"+index);
}El código anterior es encontrar el método binario de lograr, si el elemento de destino en la matriz, la salida del elemento de destino en los subíndices de matriz, mientras que la salida de -1.
Para ejecutar el método en Java, es necesario llamar a este método en el método principal, aquí está el código completo.
código completo:
public class ArraySearch{
//定义线性查找的方法，参数为目标元素
public static void LineSearch(int target){
//定义目标数组arr，并初始化
int[] arr = new int[] {1,8,10,6,30,5,12,23};
//定义目标元素的下标，初始为-1
int index=-1;
/*进行for循环，将数组中的元素与目标元素对比，如存在，则返回目标元素在
* 数组中的下标，若不存在，则返回初始下标-1
*/
for(int i=0; i<arr.length; i++) {
if(arr[i]==target) {
index = i;
break; //终止当前循环
}
}
System.out.println("线性查找算法的目标元素在数组中的下标为:"+index);
}
//定义二分查找的方法，参数为目标元素
public static void BinarySearch(int target) {
//定义目标数组newArr,并初始化，注意，二分查找的前提是：一组数是按从小到大排列的
int[] newArr = new int[] {1,2,3,4,5,6,7,8,9};
//定义目标元素的下标，初始为-1
int index = -1;
//记录数组的开始位置
int begin = 0;
//记录数组的结束位置
int end = newArr.length-1;
//记录数组的中间位置
int mid = (begin+end)/2;
//循环查找
while(true) {
//上开始位置在结束位置之后或重合，此时还没查找到目标元素，则代表数组中没有该元素，返回-1
if(begin>=end) {
return -1;
}
//判断中间的这个元素是否是要查找的元素
if(newArr[mid]==target) {
index=mid;
break;
//中间这个元素不是要查找的元素
}else {
//如果中间这个元素比目标元素大
if(newArr[mid]>target) {
end = mid-1; //把结束位置调整到中间位置的前一个元素
}else {
begin = mid+1; //把开始位置调整到中间位置的后一个元素
}
//确定新的中间元素
mid = (begin+end)/2;
}
}
System.out.println("二分查找算法的目标元素的下标为:"+index);
}
//在主方法中进行调用测试
public static void main(String[] args) {
//调用线性查找函数，将参数赋为6
LineSearch(6);
//调用二分查找函数，将参数赋为3
BinarySearch(3);
}
}Los resultados:
