Explaining Radix Sort - c++

Question

I'm trying to understand a radix sort. Particularly, I'm having trouble understanding the radixing function--more specifically, the j and k loops. I'm not sure what is exactly happening. From what I can see, it seems that the j loop is setting up indices for the k loop to utilize in forming the output array that is sorted. If anyone could help explain the logic behind it, that would be great!
// RADIX SORT BEGIN //
// Get the maximum value in arr[]
int getMax(int arr[], int size)
{
int max = arr[0]; // Set max to presumably the first one
int i = 1;
while (i < size)
{
if (arr[i] > max) // We have a new max ladies and gents
max = arr[i];
i++;
}
return max;
}
// Do a sort of arr[] based off the digit represented by exp
void radixing(int arr[], int size, int exponent)
{
int output[size];
int count[10] = {0};
// Tally the amount of numbers whose LSB based off current exponent
// is 0-9, represented by each
// index in the array
for (int i = 0; i < size; i++)
count[ (arr[i]/exponent) % 10 ]++;
for (int j = 1; j < 10; j++)
count[ j ] += count [j - 1];
for (int k = size - 1; k >= 0; k--)
{
output[ count[ (arr[k]/exponent) % 10 ] -1 ] = arr[k];
count[ (arr[k]/exponent) % 10 ]--;
}
// Finalize output into the original array
for (int o = 0; o < size; o++)
arr[o] = output[o];
}
// Main radix sort function
void radixsort(int arr[], int size)
{
// Find the max in the array to know the number of digits to traverse
int max = getMax(arr, size);
// Begin radixing by sorting the arr[] based off every digit until max
// Exponent is 10^i where i starts at 0, the current digit number
for (int exponent = 1; (max / exponent) > 0; exponent = exponent * 10)
radixing(arr, size, exponent);
}
// RADIX SORT END //

Answer 1

Rather than break down each step in the algorithm I'm going to tell you what it intends to accomplish which you can use to understand how it works. This looks like it is doing what is called an LSD radix sort.
If you've ever used a card sorter (hard to find nowadays) it does the same thing as this algorithm. The idea is to start with the least significant digit and work toward the most. The card sorter would have 10 bins -- one for each digit. A column (exponent) will be selected and the cards will fall into the proper bins depending upon what digit it had for the selected column.
What the algorithm is doing is counting the number of records with each digit in the given exponent column then outputs that many records in order. Actually, it uses the counts to compute an offset into the output array.
Now with the records in order for a given column (exponent) it moves to the next higher exponent.
Edit: embellished somewhat.

Answer 2

The j loop converts the counts into the ending index (1 + index to last element) for each bucket. The k loop moves the elements from last to first into the buckets based on the current digit. The process starts with the least significant digit, and ends with the most significant digit.
An alternative is to convert the counts into starting indexes, where the first index == 0, the second index == number of elements with '0' digits, ... (number of elements with '9' digits doesn't matter and isn't used). The radix part of the sort would sort elements from first to last.
In either case, the size of the buckets is variable, and the end of one bucket is the start of the next bucket. When a radix sort pass is completed, then there are no gaps between the buckets.