Сортировка Хоара в массиве структур - C (СИ)

Формулировка задачи:

Не могу нормально отсортировать элементы структуры с помощью быстрой сортировки. Программа просто, не прекращается, как будто цикл бесконечный. Не могу понять где ошибка. HELP!

#include <locale.h.>
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <locale.h>
#include <string.h>
struct Product {
    char name[15];
};
int N;
struct Product A[100];
struct Product X[1];
int Check_Input()
{
    char buf[BUFSIZ];
    char junk;
    int Input;
    bool ok = false;
    while (!ok)
    {
        _textcolor(7);
        fputs("Введите количество товара: ", stdout);
        fflush(stdout);
        if (fgets(buf, BUFSIZ, stdin) == NULL)
        {
            if (!ferror(stdin))
            {
                fputs("Вход не доступен!\n", stderr);
                exit(EXIT_FAILURE);
            }
            else
            {
                perror("stdin");
                clearerr(stdin);
                continue;
            }
        }
        if (sscanf(buf, "%d %c\n", &Input, &junk) != 1)
        {
            _textcolor(4);
            fputs("Неправильный ввод!\n", stderr);
            continue;
        }
        if (Input <= 0 || Input > 99)
        {
            _textcolor(4);
            fputs("Неправильный ввод!\n", stderr);
            continue;
        }
        ok = true;
    }
    return Input;
}
void speed2_inc_dec1_flat1(int l, int r)
{
    int k=(r + l) / 2;  //находят  центральный элемент
    printf("%d\n",k);
    A[N+1]=A[k];
    printf("%s\n",X[1].name);
    int i = l;
    int j = r;
    while (i <= j)
    {
        while //(A[i].name[0] > X[1].name[0])
            (strcmp(A[i].name,A[N+1].name)<0)
            i++;
        while //(A[i].name[0] < X[1].name[0])
            (strcmp(A[i].name,A[N+1].name)>0)
            j++;
        if (i <= j)
        {
            A[N] = A[j];
            A[j] = A[i];    //<----Обмен переменными
            A[i] = A[N];
            i++;
            j--;
        }
    }
    if (i < r)
        speed2_inc_dec1_flat1(i, r);
    if (l < j)
        speed2_inc_dec1_flat1(l, j);
}
void Output(struct Product *array, int size)
{
    for(int i = 0; i < size; i++)
    {
        printf("%s\n", array[i].name);
    }
}
void Input(struct Product *array, int size)
{
    for(int i = 0; i < size; i++)
    {
        printf("Введите элемент №%d: ", i+1);
        scanf("%s", &array[i].name);
    }
}
int main(int argc, char *argv[])
{
    setlocale(LC_ALL, "ru");
    system("cls");
    N=Check_Input();
    Input(A,N);
    Output(A,N);
    speed2_inc_dec1_flat1(0,N-1);
    Output(A,N);
}

Решение задачи: «Сортировка Хоара в массиве структур»

Листинг программы

void quickSort_inc(struct Product *a, int l, int r)
{
    int x = l + (r - l) / 2;
    int i = l;
    int j = r;
    while (i <= j)
    {
 
        while (strcmp(a[i].name, a[x].name) < 0)
            i++;
        while (strcmp(a[j].name, a[x].name) > 0)
            j--;
        if (i <= j)
        {
            a[N]=a[j];
            a[j]=a[i];
            a[i]=a[N];
            i++;
            j--;
        }
    }
    if (i < r)
        quickSort_inc(a, i, r);
 
    if (l < j)
        quickSort_inc(a, l, j);
}

Объяснение кода листинга программы

В функции quickSort_inc сортируется массив структур Product по полю name в порядке возрастания.
Вектор a содержит элементы, которые необходимо отсортировать.
int x = l + (r — l) / 2; используется для выбора опорного элемента из массива a.
int i = l; используется для итерации по элементам массива a слева от опорного элемента.
int j = r; используется для итерации по элементам массива a справа от опорного элемента.
В цикле while (i <= j) происходит разделение массива a на две части относительно опорного элемента.
Внутренний цикл while (strcmp(a[i].name, a[x].name) < 0) используется для поиска элементов, которые нужно поменять местами с элементом a[x].
Внутренний цикл while (strcmp(a[j].name, a[x].name) > 0) используется для поиска элементов, которые нужно поменять местами с элементом a[x].
Если найдены элементы, которые нужно поменять местами, то они меняются местами с помощью a[N]=a[j]; a[j]=a[i]; a[i]=a[N];
После выполнения внутреннего цикла, i и j инкрементируются и декрементируются соответственно, чтобы продолжить процесс разделения массива.
Если i < r, то рекурсивно вызывается функция quickSort_inc для сортировки элементов, находящихся слева от опорного элемента.
Если l < j, то рекурсивно вызывается функция quickSort_inc для сортировки элементов, находящихся справа от опорного элемента.
Код не содержит обработки ошибок.
Код не содержит выведения на экран или сохранения отсортированного массива.
Временная сложность алгоритма quickSort_inc составляет O(n log n).
Пространственная сложность алгоритма quickSort_inc составляет O(log n), так как рекурсия не создает дополнительных переменных.
Для работы алгоритма требуется дополнительная память, равная O(n), для хранения временных копий элементов массива a.
Для успешной работы алгоритма необходимо, чтобы массив a был отсортирован по полю name в порядке возрастания.
Если массив a содержит дубликаты по полю name, то они будут отсортированы в порядке возрастания.
В исходном коде отсутствует реализация функции quickSort_inc, поэтому невозможно проверить его работоспособность.