Java 不带库方法的二进制搜索

我试图构造一个二进制搜索方法，该方法遍历一个排序数组，并计算给定元素（给定为int target）是否存在。它将通过评估平均值是否大于或小于目标值来执行此操作，并将相应地循环通过数组的前半部分或后半部分

我想我已经记下了基本代码，但我遇到了一些问题：

• int目标=0；（返回true）=>正确
• int目标=（3,6,9）；（返回false）=>应返回true
• int目标=（15,19,21,90）；返回“java.lang.ArrayIndexOutOfBoundsException:15”=>应为true

我想这与各自if情况下的for语句有关，但我已经尝试过调试，但无法调试。此外，我不允许使用库方法。 希望这个问题对像我这样的初学者有帮助。我认为它探讨了一些java概念，如语法、逻辑和基本用法，谢谢您的帮助

public class ArrayUtilities
{
public static void main(String[] args) 
{
  int[] arrayBeingSearched = {0, 3, 6, 9, 12, 15, 19, 21, 90};
  int target = 90; 
  System.out.println("linear: " + linearSearch(arrayBeingSearched, target));
  System.out.println("binary: " + binarySearch(arrayBeingSearched, target)); 

}



public static boolean binarySearch(int[] arrayBeingSearched, int target)
 {

  boolean binarySearch = false;
  for (int i = 0; i < arrayBeingSearched.length; i++){
  int left = 0; //array lower bound
  int right = arrayBeingSearched.length - 1; //array upper bound
  int middle = ((right - left) / (2)); //array mean

  if(arrayBeingSearched[middle] == target){
   binarySearch = true;
  }
  else if(arrayBeingSearched[middle] < target){

    for(int j = middle + 1; j < arrayBeingSearched.length - 1; j ++){
      int newLeft = arrayBeingSearched[j ++];
      if(arrayBeingSearched[newLeft] == target){
      binarySearch = true;
      break;
      }
      else{
        binarySearch = false;
      }

    }
  }
  else if(arrayBeingSearched[middle] > target)

    for(int l = 0; l < middle - 1; l ++){
      int newRight = arrayBeingSearched[l ++];
      if(arrayBeingSearched[newRight] == target){
      binarySearch = true;
      break;
      }
      else{
        binarySearch = false;

      }
  }

  else{
    binarySearch = false;
  }
}

return binarySearch;
}

}

公共类阵列实用性
{
公共静态void main（字符串[]args）
{
int[]arrayBeingSearched={0,3,6,9,12,15,19,21,90}；
int目标=90；
System.out.println（“线性：“+linearSearch（arrayBeingSearched，target））；
System.out.println（“二进制：+binarySearch（arraybeingsearch，target））；
}
公共静态布尔二进制搜索（int[]arrayBeingSearched，int目标）
{
布尔二进制搜索=false；
for（int i=0；itarget）
对于（int l=0；l

好的，根据评论，这是更好的表达方式吗？第一条评论主要回答了我的问题，但我只想跟进：

public static boolean binarySearch(int[] array, int target)    
    {  
        int start = 0;  
        int end = array.length - 1;  

        while (start <= end)   
        {  
            int middle = start + (end - start)/2;  
            if (array[middle] == target) {  
                return true;  
            }  
            else if (array[middle] > target)    
            {  
                end = middle - 1;  
            }  
            else start = middle + 1;  
        }  
        return false;  
    }
}

公共静态布尔二进制搜索（int[]数组，int目标）
{  
int start=0；
int end=array.length-1；
while（启动目标）
{  
结束=中间-1；
}  
else start=中间+1；
}  
返回false；
}
}

这是一个糟糕的开始：

for (int i = 0; i < arrayBeingSearched.length; i++)

for（int i=0；i

这是一个线性搜索，里面还有其他东西。我还没有完全明白你在做什么，但我想你应该重新开始。。。在你面前有一个二进制搜索的描述

通常，二进制搜索循环类似于：

int left = 0;                            // Inclusive lower bound
int right = arrayBeingSearch.length;     // Exclusive upper bound
while (left < right) {
    // Either change left, change right, or return success
    // based on what you find
}

int left=0；//包含下界
int right=arrayBeingSearch.length；//排他上界
while（左<右）{
//要么向左更改，要么向右更改，要么返回成功
//根据你的发现
}

这是一个糟糕的开始：

for (int i = 0; i < arrayBeingSearched.length; i++)

for（int i=0；i

这是一个线性搜索，里面还有其他东西。我还没有完全明白你在做什么，但我想你应该重新开始。。。在你面前有一个二进制搜索的描述

通常，二进制搜索循环类似于：

int left = 0;                            // Inclusive lower bound
int right = arrayBeingSearch.length;     // Exclusive upper bound
while (left < right) {
    // Either change left, change right, or return success
    // based on what you find
}

int left=0；//包含下界
int right=arrayBeingSearch.length；//排他上界
while（左<右）{
//要么向左更改，要么向右更改，要么返回成功
//根据你的发现
}

当中间元素小于目标时，您可以这样做

int newLeft = arrayBeingSearched[j ++];
if(arrayBeingSearched[newLeft] == target) //...

当它更大的时候，它是相等的

---

也就是说，您获取数组的一个元素并将其用作索引。数组只能包含一个值为1000的元素，这就是为什么会出现ArrayIndexOutOfBoundsException。

当中间元素小于目标元素时，可以执行此操作

int newLeft = arrayBeingSearched[j ++];
if(arrayBeingSearched[newLeft] == target) //...

当它更大的时候，它是相等的

---

也就是说，您获取数组的一个元素并将其用作索引。您的数组只能包含一个值为1000的元素，这就是为什么您会遇到ArrayIndexOutOfBoundsException。

我肯定还有其他问题（请参见Jon的答案），但我想提到这样的代码：

for(int j = middle + 1; j < arrayBeingSearched.length - 1; j ++){
  int newLeft = arrayBeingSearched[j ++];

for（int j=middle+1；j

---

不会执行您想要的操作。

for

语句表示，每次程序通过循环时，它将向

j

添加1（在循环代码的末尾）。但是下一个语句将使用

j

作为索引，然后向其中添加1。结果是，每次通过循环时，都会向

j

添加1两次，因此您基本上只查看其他元素。如果这是正确的（我不认为是正确的），我想说，您肯定需要从第二行中删除

++

。

我肯定还有其他问题（请参见Jon的答案），但我想说的是这样的代码：

for(int j = middle + 1; j < arrayBeingSearched.length - 1; j ++){
  int newLeft = arrayBeingSearched[j ++];

for（int j=middle+1；j

不会执行您想要的操作。

for

语句表示，每次程序通过循环时，它都会向

j

添加1（在循环c的末尾）