在int数组上使用二进制搜索按降序排序

Question

import java.util.*;
import java.io.*;
import java.util.Arrays;
import java.util.Collections;
import org.apache.commons.lang3.ArrayUtils;
@SuppressWarnings("unused")
public class Tester {
    public static void main(String args[]){
        int i[] = {-7, 15, 21, 22, 43, 49, 51, 67, 81, 84, 89, 95, 97};
        ArrayUtils.reverse(i);
        System.out.println(binarySearch(i, 22));
        System.out.println(binarySearch(i, 89));
        System.out.println(binarySearch(i, -100));
        System.out.println(binarySearch(i, 72));
        System.out.println(binarySearch(i, 102));
    }
    private static int binarySearch(int a[], int srchVal){
        int lb = 0;
        int ub = a.length - 1;

        while(lb <= ub){
            int mid = (lb + ub)/2;
            if(a[mid] == srchVal){
                return mid;
            }
            else if(srchVal > a[mid]){
                lb = mid + 1;
            }
            else{
                ub = mid - 1;
            }
         }
        return -1;
    }
}

For an assignment in class I need to modify the BinarySearch method so that it will work properly with the reversed array. But I can't figure out how I'm supposed to modify it.

Answer 1

If the array is sorted in descending order, binary search can still work if you reverse the sense of all value comparisons performed by the search algorithm.

The equals case is still fine, but you can reverse the comparison made in the else if to a < . The else doesn't need to be modified, because the else if change means the else block will now represent the > condition.

Answer 2

Binary search makes the assumption the data is ordered . If that's the case, than one knows if the value of the selected index ( mid ) is less than the value, the value must be in the range 0..mid-1 and vice versa.

In case the array is ordered in reverse, one knows that if the value is less, then one must search in the second part. The only thing you must modify is the condition in the else if :

else if(srchVal < a[mid]){ //change < to >
    lb = mid + 1;
}

That said, one better makes the method a bit more generic so one can make the comparator more generic as well:

private static<T> int binarySearch(T[] a, Comparator<T> c, T srchVal){
    int lb = 0;
    int ub = a.length - 1;

    while(lb <= ub){
        int mid = (lb + ub)/2;
        int ci = c.compare(a[mid],srchVal);
        if(ci == 0){
            return mid;
        }
        else if(ci < 0){
            lb = mid + 1;
        }
        else{
            ub = mid - 1;
        }
     }
    return -1;
}

In case you provide a reversed array, you only need to provide a Comparator<T> that returns -val with val the comparator for the original array.

Answer 3

There is a hack: 1) Reverse whole array so that now it is increasing order array. 2) Apply binary search and then find suitable index. 3) n-index will be your answer.

Answer 4

Binary searches work on sorted sets. Your code assumes that the order is ascending, yet, it is the inverse. As a result, you need to invert the condition:

while(lb > ub){

On more general terms, you could be agnostic about the direction:

private static int binarySearch(int a[], int srchVal, boolean isAscending){
    int lb = 0;
    int ub = a.length - 1;

    while((lb <= ub) == isAscending){
        int mid = (lb + ub)/2;
        if(a[mid] == srchVal){
            return mid;
        }
        else if(srchVal > a[mid]){
            lb = mid + 1;
        }
        else{
            ub = mid - 1;
        }
     }
    return -1;
}

and use ascending order by default:

private static int binarySearch(int a[], int srchVal){
    return binarySearch(a, srchVal, true);
}

but descending in your case

public static void main(String args[]){
    int i[] = {-7, 15, 21, 22, 43, 49, 51, 67, 81, 84, 89, 95, 97};
    ArrayUtils.reverse(i);
    System.out.println(binarySearch(i, 22), false);
    System.out.println(binarySearch(i, 89), false);
    System.out.println(binarySearch(i, -100), false);
    System.out.println(binarySearch(i, 72), false);
    System.out.println(binarySearch(i, 102), false);
}

Answer 5

Just change srchVal > a[mid] condition to srchVal < a[mid]

import java.util.*;

import java.io.*;

import java.util.Arrays;

import java.util.Collections;

public class HelloWorld{

    private static int binarySearch(int a[], int srchVal){
        int lb = 0;
        int ub = a.length - 1;

        while(lb <= ub){
            int mid = (lb + ub)/2;
            if(a[mid] == srchVal){
                return mid;
            }
            else if(srchVal < a[mid]){
                lb = mid + 1;
            }
            else{
                ub = mid - 1;
            }
         }
        return -1;
    }

     public static void main(String []args){
         int i[] = {97,95,89,84,81,67,51,49,43,22,21,15,-7};
         System.out.println(binarySearch(i, 22));
         System.out.println(binarySearch(i, 89));
         System.out.println(binarySearch(i, -100));
         System.out.println(binarySearch(i, 72));
         System.out.println(binarySearch(i, 102));
     }
}

Answer 6

You can pass a reverse comparator in the binary search when you want to run the binary search in an array which is sorted in descending order. Example:

Integer [] arr = new Integer[]{5,6,2,9,7};
Arrays.sort(arr, Collections.reverseOrder()); //sorting the array in descending order
Arrays.binarySearch(arr, 2, Comparator.reverseOrder()) // Searches of for 2 in the array.

The above function will return 4 which is the index of 2 in reverse sorted array. It also works as usual if the element is not present in the array. For example, if you search of value 3, it will return -5. (-insertion index -1) Check this for details.

Thanks