randomHash

#include <iostream>
#include <chrono>
#include <functional>

const int maxTry = 200;

struct Hash
{
    uint16_t key;
    uint16_t value;
};

void initHash(Hash** hashArr)
{
    for (int i = 0; i < maxTry; i++)
    {
        hashArr[i] = nullptr;
    }
}
int incrementHash(Hash** hashArr, uint16_t key)
{
    int i = 0;
    for (; hashArr[i] and (i < maxTry); i++)
    {
        if (hashArr[i]->key == key)
        {
            hashArr[i]->value++;
            return 0;
        }
    }
    hashArr[i] = new Hash{ key,1 };
    return 1;
}

void trashHash(Hash** hashArr)
{
    int i = 0;
    for (; hashArr[i] and (i < maxTry); i++)
    {
        delete hashArr[i];
    }
}

void printHash(Hash** hashArr)
{
    int i = 0;
    for (; hashArr[i] and (i < maxTry); i++)
    {
        std::cout << hashArr[i]->key << " : " << hashArr[i]->value << "\n";
    }
}

int sizeHash(Hash** hashArr)
{
    int i = 0;
    for (; hashArr[i] and (i < maxTry); i++);
    return i;
}

template <typename T> int sortUp(T a, T b)
{
    return a->value < b->value;
}

template <typename T> int sortDown(T a, T b)
{
    return a->value > b->value;
}

template <typename T> void sortArr(T* arr, int arrSize, std::function<int(T, T)> sortCrit)
{

    for (int head = 0; head < arrSize; head++)
    {
        for (int tail = arrSize - 1; tail > head; tail--)
        {

            if (sortCrit(arr[tail], arr[head]))
            {
                T tmp = arr[tail];
                arr[tail] = arr[head];
                arr[head] = tmp;

            }
        }

    }
}

int main()
{
    srand(time(0));

    Hash* randomHash[maxTry];

    initHash(randomHash);

    for (int i = 0; i < maxTry; i++)
    {
        incrementHash(randomHash, (uint16_t) (rand() % 1000));
    }

//  printHash(randomHash);

    std::cout << sizeHash(randomHash) << "\n";

    sortArr<Hash*>(randomHash, sizeHash(randomHash), sortDown<Hash*>);

    printHash(randomHash);

    trashHash(randomHash);

}