需要帮助查看我的二进制搜索程序

Question

I am trying to implement a binary search in Java, but I am having some issues with my code. It works if the element I am looking for exists in the array. If it doesn't, the program doesn't print an error message. What I mean here is -

When I run my code - this is the output -

Please enter array size
2
Please enter element 0
3
Please enter element 1
4
Sorted array elements[3, 4]


Please enter the element you want to find in the array
3
Match 3 found at index 0

If however, I look for an element that doesn't exist in the array, the program doesn't enter the else loop, and print an error message - It instead does this -

Please enter array size
2
Please enter element 0
3
Please enter element 1
4
Sorted array elements[3, 4]


Please enter the element you want to find in the array
2
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: -1
    at arraysPract.BinarySearch.findElement(BinarySearch.java:82)
    at arraysPract.BinarySearch.main(BinarySearch.java:54)

Here is the code -

package arrays;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;

public class BinarySearch {
    static int[] binaryArr = null;

    public static void main(String[] args) {
        BufferedReader br = null;
        String size = "";

        try {
            System.out.println("Please enter array size");
            br = new BufferedReader(new InputStreamReader(System.in));
            size = br.readLine();
            if (size == null) {
                System.out.println("Size can't be null");
                return;
            }
            int ipSize = Integer.parseInt(size);
            binaryArr = new int[ipSize];
            String entry = "";
            for (int i = 0; i < ipSize; i++) {
                System.out.println("Please enter element " + i);
                entry = br.readLine();
                if (entry == null) {
                    System.out.println("Value can't be null");
                    return;
                }
                int arrEntry = Integer.parseInt(entry);
                binaryArr[i] = arrEntry;
            }

            Arrays.sort(binaryArr);
            System.out.println("Sorted array elements"  + Arrays.toString(binaryArr));
            System.out.println("\n");

            System.out.println("Please enter the element you want to find in the array");
            String findArrayElement = br.readLine();
            int find = Integer.parseInt(findArrayElement);      
            boolean elementExists = Arrays.asList(binaryArr).contains(find);            
            if (elementExists==false) {             
                findElement(binaryArr, find);
            }

            else {
                System.out.println("Element does not exist. Please try again");
            }

        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static int findElement(int[] test, int keyElement) {
        boolean flag = true;
        int i = 0;
        for (i = test.length / 2; i >= 0 && i < test.length;) {
            if (keyElement == test[i]) {
                flag = false;
                break;
            } else if (keyElement > test[i]) {
                i++;
                if (keyElement == test[i]) {
                    flag = false;
                } else {
                    flag = true;
                }
            } else if (keyElement < test[i]) {
                i--;
                if (keyElement == test[i]) {
                    flag = false;
                } else {
                    flag = true;
                }
            }
        }

        if (flag == false) {
            System.out.println("Match " + keyElement + " found at index " + i);
        }
        return i;
    }
}

Request someone to please guide me if I am overlooking something thats an obvious error?

Also, there are several possible duplicates for this post - Binary search in java , Binary search in java etc. I just need help with reviewing my code, not in implementing the program :)

Answer 1

This is not binary search, you should keep dividing indices by two (or recurring, in recursive version). Instead, you are doing linear search, complicated (linear because index is incremented/decremented by 1, a constant, at each step) on the two halves of the array.

Anyway, your problem with 2 is that it is smaller than the smallest element of the array, so i gets decremented until it reaches 0 (first element); at that point, this line is executed:

i--;

And then, test[i] is called for comparison. But i will be -1, out of bounds. Call i-- after test, not before.

Please throw away your code, read carefully this good reference and implement binary search right: code is very straightforward if you understand how binary search works.

EDIT: have a look here for linear search.

Answer 2

It is not a binary search because you are merely iterating over the upper or lower half of the array. This provides performance of O(n/2), or in other words O(n). Binary search continuously halves the area that it is searching, which provides O(log n).

In this block of code:

        } else if (keyElement > test[i]) {
            i++;
            if (keyElement == test[i]) {

The second if statement in this block does nothing, you know that keyElement is > test[i] , so it can not also be equal!

Answer 3

Let me try and clear up what a binary tree is and hopefully it can make writing your code a little easier.

Binary search can be thought of as a bunch of variables scattered in a tree. If for example the root or the top of the tree has the number 8, then everything that falls to the left side is less or equal to 8 and everything that branches to the right of that node is greater.

Answer 4

Regardless of whether or not you are using the correct algorithm, the reason that your code is throwing the ArrayOutOfBoundsException is that you continue to increment or decrement i in the case where incrementing or decrementing i sets the flag to false. In the case where entering a loop iteration finds a match, you break out of the loop; in the other two cases, you increment/decrement the loop and then check again, but you don't break if the flag is changed. This would be a case where it would be better to use a while or do/while loop. If you remove the second check after the increment or decrement, you will achieve what it appears you mean to do.

As far as the algorithm goes, you aren't incrementing an array index, you're cutting your search range in half each time through the array.

The useful thing to take away from this is that the exception and stack trace tell you what's wrong (the array index is -1) and where it happened, method and line (at ArraysPract.BinarySearch.findElement(BinarySearch.java:82)