在InsertInOrder中使用递归二进制搜索

Question

I'm reading in a text file of unsorted numbers

static void insertInOrder( int[] arr, int cnt, int newVal )
    {
        int belongs = -( bSearch( arr, 0, arr.length-1, newVal)) - 1;
        {
            for ( int i = cnt; i >= belongs+1 ; --i)
            {
                arr[i] = arr[i-1];
            }

        arr[belongs] = newVal;
    }

    }

    // We do not need to pass in count. The incoming lo and hi define the range
    public static int bSearch(int[] a, int lo, int hi, int key)
    {
    int mid = (lo+hi)/2;
    if(lo>hi)
        return -1;
    else if (a[mid]==key)
        return mid;
    else if (a[mid]<key)
        return bSearch(a, mid+1, hi, key);
    else
        return bSearch(a, lo, mid-1, key);
    }

The binary search is working, but my insertinorder isn't putting the numbers in ascending order and I can't figure out why. It's just printing the list out backwards. And this has to be done using a recursive binary search in an insertinorder.

Answer 1

Have you copied the latest code in to the question ???.

One obvious problem is:

int belongs = -( bSearch( arr, 0, arr.length-1, newVal)) - 1;

the method bSearch returns -1 when a value is not found in the array. This will give an insertion point of -2 when newValue is not found. You need to change bSearch to return both wether the item was found and the position. Two options

1. Create (and return) a new class

    private class FoundResult { boolean found = true; int position; } 

2. When not found; return -hi-1 ie in bSearch some thing like:

    if(lo>hi) return -hi-1; 

---

For option 1, the code will be roughly (i have not tested this):

static void insertInOrder( int[] arr, int cnt, int newVal )     {

    int belongs = bSearch( arr, 0, arr.length-1, newVal)).position ;
    for ( int i = cnt; i >= belongs+1 ; --i) {
       arr[i] = arr[i-1];
    }

    arr[belongs] = newVal;
}

// We do not need to pass in count. The incoming lo and hi define the range
public static FoundResult bSearch(int[] a, int lo, int hi, int key)
{
int mid = (lo+hi)/2;
FoundResult ret;
if(lo>hi) {
    ret = new FoundResult();
    ret.found = false;
    ret.position = hi;
    return ret;
} else if (a[mid]==key) {
    ret = new FoundResult();
    ret.position = hi;
    return ret;
} else if (a[mid]<key) {
    return bSearch(a, mid+1, hi, key);
} else {
    return bSearch(a, lo, mid-1, key);
}

---

For option 2 the code is roughly:

static void insertInOrder( int[] arr, int cnt, int newVal )     {

    int belongs = bSearch( arr, 0, arr.length-1, newVal)) ;
    if (belongs < 0) {
        belongs  = -1 - belongs ;
    }
    for ( int i = cnt; i >= belongs+1 ; --i) {
       arr[i] = arr[i-1];
    }

    arr[belongs] = newVal;
}

// We do not need to pass in count. The incoming lo and hi define the range
public static int bSearch(int[] a, int lo, int hi, int key)
{
int mid = (lo+hi)/2;
FoundResult ret;
if(lo>hi) {
    return - hi - 1;
} else if (a[mid]==key) {
    return hi;
} else if (a[mid]<key) {
    return bSearch(a, mid+1, hi, key);
} else {
    return bSearch(a, lo, mid-1, key);
}