Question

I’ve been given the basic code for an algorithm, which selects the kth smallest element in an unsorted array (or sorted, I’m not sure). Usually, we’d use quickselect for this, but we’ve been given another choice which has been labelled ‘countingselect’ as the function name.

“Counting select uses a similar approach to counting sort. Items in the list are used as indexes into an array of counts. Then, starting at the low value end of the array, item counts are accumulated until the total exceeds the desired value.”

// return the kth smallest item
int countingSelect(int items[], int first, int last, int k) {
    int counts[cap];
    for (int c = 0; c < cap; c++) {
        counts[c] = 0;
    }
    for (int i = first; i < last; i++) {
        counts[items[i]] += 1;
    }
    int c = 0;
    while (k >= 0) {
        k -= counts[c++];
    }
    return c-1;
}

I’m having enormous trouble breaking this down into pseudo-code, so that I can understand exactly how the function works. With the code we’ve been given, my first confusion is what the value ‘cap’ is, and what it’s function is. What value is cap usually? I haven’t been given this information.

Breaking down the algorithm into pseudo code is a good way to understand it, and I request some aid in breaking it down and stepping through the code.

Thankyou in advance.

Answer 1

If you have understood count sort, this should be quite simple. If not, then let me briefly say how count sort works.

Say you have 10 numbers, in the range [0, 15]. Since you know the bound of data, you can go over your input, and mark how many times you see each number. Then you iterate over the counts and retrieve the numbers in order:

input numbers
counts[0..15] = 0
for i in numbers
    ++counts[numbers[i]]
for i in counts
    counts[i] times
        print i

Let’s see an example:

numbers: 1 5 3 13 5 2 0 1 14 2

The first loop creates the counts:

(index) 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
counts: 1 2 2 1 0 2 0 0 0 0 0  0  0  1  1  0

And the second loop gives you:

1 times 0
2 times 1
2 times 2
1 time 3
0 times 4
2 times 5
0 times 6
...

that is:

0 1 1 2 2 3 5 5 13 14

---

Your algorithm is basically the same, except instead of outputting a sorted list, it find the kth smallest item.

In the example above, you can see that:

0th smallest numbers is 0
1st and 2nd smallest numbers are 1
3rd and 4th smallest numbers are 2
5th smallest number is 3
6th and 7th smallest numbers are 5
...

If you look closely, you will see this pattern:

if      k <= 0 => 0
else if k <= 2 => 1
else if k <= 4 => 2
else if k <= 5 => 3
else if k <= 7 => 5
else if k <= 8 => 13
else if k <= 9 => 14

However, the numbers

0 2 4 5 7 8 9

are in fact the running sum of counts itself!

So, what the bottom of your algorithm does is a running sum, except it checks when the sum gets bigger than k. When it does, the previous number had been your answer. Note that the indices to counts are the numbers themselves.

int c = 0;
int sum = 0;
while (k >= sum) {
    sum += counts[c++];
}
return c-1;

Your algorithm has tried to avoid the sum variable and instead subtracts the running sum from k itself which has the same effect.