Please explain the code in this count sort - c++

Question

I was learning count sort from tutorial and my C++ source code is given below:
#include <iostream>
#include <string.h>
using namespace std;
void countSort(int arr[], int size)
{
//declare output array
int output[size];
//declare count array
int count[size];
//initialize count[] with zero
//memset ( void * ptr, int value, size_t num )
memset(count, 0, sizeof(count));
//input array element is the index of count array
//storing the repetition/frequency
for(int i=0; i<size; i++){
count[arr[i]]++;
}
/*
Modify the count array such that each element at
each index stores the sum of previous counts.
*/
// i=1 because, previous is 0 due to avoid -1
for(int i=1; i<size; i++){
count[i] += count[i-1];
}
//Build ouput array
//count array element is the index of output array
for(int i=0; i<size; i++){
//***********THIS LINE***********
output[count[arr[i]]-1] = arr[i];
count[arr[i]]--;
}
//copy ouput array into input array arr[]
for(int i=0; i<size; i++){
arr[i] = output[i];
}
}
void printArray(int arr[], int size){
// Ascending order
for(int i=0; i<size; i++){
cout<<arr[i]<<" ";
}
cout<<endl;
}
int main() {
// your code goes here
int arr[] = {1,4,1,2,7,5,2,6,6,9};
int size= sizeof(arr)/sizeof(arr[0]);
countSort(arr, size);
printArray(arr, size);
return 0;
}
I understand about taking sorted array in output array.However why we need to decrements the output index by -1:
output[count[arr[i]]-1] = arr[i];
I didn't understand this part. I try with only output[count[arr[i]]] but it doesn't gave me the correct sorted array.

Answer 1

The array of counts was converted in to an array of ending indices, point one past the end of each logical bucket, so 1 is subtracted from each index. This could be combined to use pre-decrement, and the array scanned backwards:
for(i=size; i; ){
i--;
output[--count[arr[i]]] = arr[i];
}
Getting back to the counts after they are summed up, note that count[0] contains a count of all the elements equal to zero, and count[1] contains a count of all elements == zero and all elements == 1, and so on, so count[0] is the logical size of the bucket that will contain the zeroes, and the size is 1 greater than the index to the last element. The same logic applies to count[1] and so on.
Example code where the counts are converted into starting indices. output[] converted to use new (to avoid stack overflow and some compilers don't support variable length arrays). count[10] assumes the range of numbers is limited to 0 through 9.
#include <iostream>
#include <stdlib.h>
using namespace std;
void countSort(int arr[], int size)
{
//declare output array
int * output = new int[size];
//declare count array
// assumes range of values is 0 to 9
int count[10];
//initialize count[] with zero
for(int i=0; i<size; i++)
count[i] = 0;
//input array element is the index of count array
//storing the repetition/frequency
for(int i=0; i<size; i++){
count[arr[i]]++;
}
// convert counts into starting indices (this is the main change)
int sum = 0, tmp;
for(int i=0; i<size; i++){
tmp = count[i];
count[i] = sum;
sum += tmp;
}
//Build ouput array
//count array element is the index of output array
for(int i=0; i<size; i++){
output[count[arr[i]]++] = arr[i];
}
//copy ouput array into input array arr[]
for(int i=0; i<size; i++){
arr[i] = output[i];
}
delete[] output;
}
void printArray(int arr[], int size){
// Ascending order
for(int i=0; i<size; i++){
cout<<arr[i]<<" ";
}
cout<<endl;
}
int main() {
int arr[] = {1,4,1,2,7,5,2,6,6,9};
int size= sizeof(arr)/sizeof(arr[0]);
countSort(arr, size);
printArray(arr, size);
return 0;
}