Implementing counting sort with custom objects - swift

Question

I want to implement a counting sort but want to implement this with custom objects. This is in Swift, but the implementation details are not too important.
I want to sort an object which basically just holds an Integer (key) and a character.
class ToSort : CustomStringConvertible {
var description: String {
return String(num)
}
var num : Int
var val : Character
init(_ num: Int, _ val : Character) {
self.num = num
self.val = val
}
}
Now usually the frequencies of integers are stored (https://www.geeksforgeeks.org/counting-sort/). I want to store my objects - I'm not sure how to do this. I've spent some time looking for implementations (with custom objects - I've got a link just above here for the standard implementation), cannot find one and cannot work out how I should implement this...
I think I can do this by implementing a dictionary (hashmap), but if I'm doing that is the advantage of using a counting sort lost?

Answer 1

You can try this algorithm i implemented it to use custom object might give you an idea of how its done,
struct Foo {
var number: Int
var name: String
}
enum CountingSortError: Error {
case arrayEmpty
}
func countingSort(array: [Foo]) throws -> [Foo] {
guard array.count > 0 else {
throw CountingSortError.arrayEmpty
}
// Step 1
// Create an array to store the count of each element
let maxElement = array.max{ a, b in a.number < b.number } ?? Foo(number: 0, name: "Zero")
var countArray = [Int](repeating: 0, count: Int(maxElement.number + 1))
for element in array {
countArray[element.number] += 1
}
// Step 2
// Set each value to be the sum of the previous two values
for index in 1 ..< countArray.count {
let sum = countArray[index] + countArray[index - 1]
countArray[index] = sum
}
print(countArray)
// Step 3
// Place the element in the final array as per the number of elements before it
let count = array.count
var sortedArray = [Foo](repeating: Foo(number: 0, name: ""), count: count)
sortedArray = array.sorted(by: { (a, b) -> Bool in
countArray[a.number] -= 1
return a.number < b.number
})
return sortedArray
}
Usage :
print(try countingSort(array: [Foo(number: 10, name: ""), Foo(number: 9, name: ""), Foo(number: 8, name: ""), Foo(number: 7, name: ""), Foo(number: 1, name: ""), Foo(number: 2, name: ""), Foo(number: 7, name: ""), Foo(number: 3, name: "")]).flatMap {$0.number})
Output
count [0, 1, 2, 3, 3, 3, 3, 5, 6, 7, 8]
sorted [1, 2, 3, 7, 7, 8, 9, 10]
The base algorithm code