C++ qsort的无限计算

根据科尔曼的说法，我正在实现qsort算法。但当我试图开始它时，有无限的计算。我想，那个问题是在分区中。我的程序从文件中读取数据，文件行中的第一个数字是要排序的数字计数，接下来是所有数字

#include <stdio.h>
#include <stdlib.h>

int swap(int &a, int &b);
int sorting(int *array, int &b, int &l);
int partition(int *array ,int &begin, int &last);


int main()
{
    FILE* pFile=fopen("input.txt", "r");
    //fopen("input.txt", "r");
    //fopen("output.txt", "w");
    int n;
    int begin=0;
    fscanf(pFile, "%d", &n);
    int* array=(int*)malloc(n*sizeof(int));
    for (int i=0; i<n; ++i)
        fscanf(pFile,"%d", &array[i]);
    int n1=n-1;
    sorting(array, begin, n1);
    printf("JJJJ");
    for (int i=0; i<n; ++i)
        printf("%d ", array[i]);
    printf("\n");
    fclose(pFile);
    free(array);
    return 0;
}

int sorting(int* array, int &b, int &l)
{
    int pivot,pivot1;
    if(b<l)
    {
        pivot=partition(array, b, l);
        printf("MAXMAX321");
        int a=pivot-1;
        sorting(array, b, a);
        printf("MAXMAX123");
        pivot1=pivot+1;
        sorting(array, pivot1, l);
        printf("MAXMAX");
    }
    return 0;
}

int partition(int* array, int &b, int &l)
{
    int x=array[b];
    int i=b;
    int j=l;
    while(true)
    {
        while(array[j]>x){
            printf("AHAH");
            --j;
        }
        while(array[i]<x){
            printf("AZAZA");
            ++i;
        }
        if(i<j)
            swap(array[i],array[j]);
        else
            return j; 

    }
}

int swap(int &x, int &y)
{
    x=x+y;
    y=x-y;
    x=x-y;
    return 0;
}

#包括
#包括
内部掉期（内部和a、内部和b）；
整数排序（整数*数组、整数和b、整数和l）；
int分区（int*数组、int和begin、int和last）；
int main（）
{
FILE*pFile=fopen（“input.txt”、“r”）；
//fopen（“input.txt”、“r”）；
//fopen（“output.txt”、“w”）；
int n；
int begin=0；
fscanf（pFile、%d、&n）；
int*数组=（int*）malloc（n*sizeof（int））；
对于（int i=0；i我无法理解您在函数分区中做什么，但这样做应该可以：

int partition(int* array, int &b, int &l)
{
    int pivot_index = l;//You can take here everything between b and l
    //swap(array[l], array[pivot_index]); decomment this if your pivot is between b and l
    int current_pos = b;
    for(int i = b;i < l - 1; ++i)
        if(array[i] <= array[pivot_index])
            swap(array[i], array[current_pos++]);
    swap(array[l], array[current_pos]);
    return current_pos;
}

int分区（int*数组、int&b、int&l）
{
int pivot_index=l；//在这里可以获取b和l之间的所有内容
//交换（数组[l]，数组[pivot_index]）；如果你的pivot在b和l之间，则取消此项
int current_pos=b；
对于（int i=b；i如果（数组[i]此部分是非常危险的代码：

while(true)
{
    while(array[j]>x){
        printf("AHAH");
        --j;
    }
    while(array[i]<x){
        printf("AZAZA");
        ++i;
    }
    if(i<j)
        swap(array[i],array[j]);
    else
        return j; 

}

while（true）
{
while（数组[j]>x）{
printf（“AHAH”）；
--j；
}
虽然（数组）不工作，但没有错误，但答案是错误的，为什么应该是这个标记的C++？除了引用的使用之外，这是纯C代码。