Need help implementing Radix sort to handle negative values

Question

Hi !
I'm in desperate need for some help here...
I've been struggling with this Radix sort algorithm for some time now. It sorts positive integers very well, and very fast, but it cant handle negative values. Is there anyone who can help me improve this algorithm to also sort negative integer values?
I need it to be as fast or even faster then the current one, and it has to be able to sort values in an array from address x -> y.
Here's what I have so far
/** sorts an int array using RadixSort (can only handle positive values [0 , 2^31-1])
      * @param a an array to be sorted
      * @param b an array of the same size as a (a.length) to be used for temporary storage
      * @param start start position in a (included)
      * @param stop stop position in a (excluded)
     public void sort(int[] a, int[] b, int start, int stop){
          int[] b_orig = b;
          int rshift = 0, bits = 8;
          for (int mask = ~(-1 << bits); mask != 0; mask <<= bits, rshift += bits) {
               int[] cntarray = null;
               try{cntarray = new int[1 << bits];}catch(Exception e){System.out.println("Error");};
               for (int p = start; p < stop; ++p) {
                    int key = (a[p] & mask) >> rshift;
                    ++cntarray[key];
               for (int i = 1; i < cntarray.length; ++i)
                    cntarray[i] += cntarray[i-1];
               for (int p = stop-1; p >= start; --p) {
                    int key = (a[p] & mask) >> rshift;
                    --cntarray[key];
                    b[cntarray[key]+start] = a[p];
               int[] temp = b; b = a; a = temp;
          if (a == b_orig)
               System.arraycopy(a, start, b, start, stop-start);
     }I think it can be solved by offsetting all positive values the with the number of negative values found in "a" during the last run through the main for loop (as the last (or first) 8 bits in an 32 bit integer contains the prefix bit (first bit in an 32 bit integer), 0 for positive value, 1 for negative).
Thanks in advance !
/Sygard.

Answer 1

ah, beautiful !
/** sorts an int array using RadixSort (can handle values [-2^31 , 2^31-1])
      * @param a an array to be sorted
      * @param b an array of the same size as a (a.length) to be used for temporary storage
      * @param start start position in a (included)
      * @param stop stop position in a (excluded)
     public void sort(int[] a, int[] b, int start, int stop){
          int[] b_orig = b;
          int rshift = 0;
          for (int mask = ~(-1 << bits); mask != 0; mask <<= bits, rshift += bits) {
               int[] cntarray = null;
               try{cntarray = new int[1 << bits];}catch(Exception e){System.out.println("Error");};
               if(rshift == 24){
                    for (int p = start; p < stop; ++p) {
                         int key = ((a[p] & mask) >>> rshift) ^ 0x80;
                         ++cntarray[key];
                    for (int i = 1; i < cntarray.length; ++i)
                         cntarray[i] += cntarray[i-1];
                    for (int p = stop-1; p >= start; --p) {
                         int key = ((a[p] & mask) >>> rshift) ^ 0x80;
                         --cntarray[key];
                         b[cntarray[key]+start] = a[p];
                    int[] temp = b; b = a; a = temp;
               else{
                    for (int p = start; p < stop; ++p) {
                         int key = (a[p] & mask) >>> rshift;
                         ++cntarray[key];
                    for (int i = 1; i < cntarray.length; ++i)
                         cntarray[i] += cntarray[i-1];
                    for (int p = stop-1; p >= start; --p) {
                         int key = (a[p] & mask) >>> rshift;
                         --cntarray[key];
                         b[cntarray[key]+start] = a[p];
                    int[] temp = b; b = a; a = temp;
          if (a == b_orig)
               System.arraycopy(a, start, b, start, stop-start);
     }That's what I ended up with - and it works !
Thanks a million !!