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

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

    //cout << pivotSkis.id << endl;

    int idSkis1 = leftBorder;
    int idSkis2 = rightBorder;

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

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

        if (idSkis1 >= idSkis2)
        {
            break;
        }

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

    int idStudents1 = leftBorder;
    int idStudents2 = rightBorder;

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

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

        if (idStudents1 >= idStudents2)
        {
            break;
        }

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

    return idSkis2;
}


/*
 * Если возможно, разделяю массив соответствующим методом, и рекурсивно вызываю текущий метод
 * для двух его частей
 */
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;
    }
}

void findPairs(Student* students, Ski* skis, int n)
{
    quickSortWithBorders(students, skis, 0, n - 1);
}