int partition(Student *students, Ski *skis, int leftBorder, int rightBorder)
{
    //
    Student pivot = students[(leftBorder + rightBorder) / 2];
    Ski pivotSkis;

    for (int i = 0; i < sizeof(students); ++i)
    {
        if (compare(pivot, skis[i]) == 0) {
            pivotSkis = skis[i];
            break;
        }
    }

    int idSkis1 = leftBorder;
    int idSkis2 = rightBorder;

    while (idSkis1 <= idSkis2)
    {
        while (compare(pivot, skis[idSkis1]) == -1)
        {
            idSkis1++;
        }

        while (compare(pivot, skis[idSkis2]) == 1)
        {
            idSkis2--;
        }

        if (idSkis1 >= idSkis2)
        {
            break;
        }

        swap(skis[idSkis1++], skis[idSkis2--]);
    }

    int idStudents1 = leftBorder;
    int idStudents2 = rightBorder;

    while (idStudents1 <= idStudents2)
    {
        while (compare(students[idStudents1], pivotSkis) == -1)
        {
            idStudents1++;
        }

        while (compare(students[idStudents2], pivotSkis) == 1)
        {
            idStudents2--;
        }

        if (idStudents1 >= idStudents2)
        {
            break;
        }

        swap(students[idStudents1++], students[idStudents2--]);
    }


    return idStudents2;
}


/*
 * Если возможно, разделяю массив соответствующим методом, и рекурсивно вызываю текущий метод
 * для двух его частей
 */
void quickSortWithBorders(Student *students, Ski *skis, int leftBorder, int rightBorder)
{
    if (leftBorder < rightBorder)
    {
        int middle = partition(students, skis, leftBorder, rightBorder);
        quickSortWithBorders(students, skis, leftBorder, middle);
        quickSortWithBorders(students, skis, middle + 1, rightBorder);
    }
    else
    {
        return;
    }
}