template <class Type>
void
BucketSort(Vector<Type> & a, int n, int radix)
// precondition: radix is upper bound on largest element of a
//               n = # of elements of a
//     
// from Sedgewick, modified as explanation given in Weiss (advanced)
// does "bucket sort"
{
    static Vector<int> count(radix,0);   // one per program
    int k,j,index;
    
    for(k=0;k<n;k++){             // count occurrences of each element
        count[a[k]]++;
    }
    index = 0;
    for(k=0; k < radix; k++){
        for(j=0; j < count[k]; j++){
            a[index] = k;
            index++;
        }
    }
}

// the bits macro returns the z bits that are y bits from the right in 
// the number x --- taken from Algorithms by Sedgewick

#define bits(x,y,z) ((unsigned) ( (((unsigned)(x)) >> (y)) & ~(~0 << (z)) ))
#define WORDSIZE 8         // number of "chunks" at a time
#define WORDS_PER_INT  4
#define WORD_VALUES  (1 << WORDSIZE)   // 2^WORDSIZE

template <class Type>
void
RadixSort(Vector<Type> & a,int n)
// precondition: n = # of elements of a
//     
// from Sedgewick, (code in book is incorrect!!)
{
    static Vector<int> count(WORD_VALUES);      // once per program
    int j,k,radix=WORD_VALUES;

      // see Sedgewick for explanation (yeah, right)
    
    for(j=0;j<WORDS_PER_INT;j++){
        count.Fill(0);                // zero vector

        for(k=0;k<n;k++){
            count[bits(a[k],j*WORDSIZE,WORDSIZE)]++;
        }

        for(k=1;k<radix;k++){
            count[k] += count[k-1];
        }

        for(k=n-1;k>=0;k--){
            extra[--count[bits(a[k],j*WORDSIZE,WORDSIZE)]] = a[k];
        }

        for(k=0;k<n;k++){
            a[k] = extra[k];
        }
    }
}