C 我的快速排序无法正常工作。我做错了什么？

我的快速排序无法排序。我不明白为什么。当我进行两次排序时，它的排序是正确的，但如果我们使用快速排序两次，它就不是快速排序

---

我的任务是编写一个通用的快速排序函数，以便对任何类型的数组进行排序。在函数中，我们得到一个指向字符串的指针，用于排序、字符串的长度、一个元素的大小和比较函数

我的比较函数：

int icmp(void* x, void* y)
{
    int a = *(int*)x;
    int b = *(int*)y;
    if (a > b) {
        return 1;
    }
    else if (a < b) {
        return -1;
    }
    else {
        return 0;
    }
}

int-icmp（void*x，void*y）
{
int a=*（int*）x；
int b=*（int*）y；
如果（a>b）{
返回1；
}
否则如果（a

我的交换函数：

void swapper(void* x, void* y, size_t size)
{
    char* a = NULL;
    if ((a = (char*)malloc(size * sizeof(char*))) == NULL) {
        return NULL;
    }
    for (int i = 0; i < size; i++) {
        a[i] = *((char*)x + i * sizeof(char*));
    }
    *(char*)x = *(char*)y;
    *(char*)y = *a;
}

void交换程序（void*x，void*y，size\u t size）
{
char*a=NULL；
如果（（a=（char*）malloc（size*sizeof（char*）））==NULL）{
返回NULL；
}
对于（int i=0；i

我的排序功能：

void my_qsort(const void* ptr, size_t count, size_t size, int (*cmp)(const void*, const void*))
{
    sort(ptr, 0, count - 1, size, cmp);
}

void sort(const void* ptr, int low, int high, size_t size, int (*cmp)(const void*, const void*))
{
    int i = low;
    int j = high;
    char* mid = (char*)ptr + ((i + j) / 2) * size;
    while (i <= j)
    {
        while ((cmp((char*)ptr + i * size, mid) == -1)) {
            i++;
        }
        while (cmp((char*)ptr + j * size, mid) == 1) {
            j--;
        }
        if (i <= j) {
            swapper((char*)ptr + i * size, (char*)ptr + j * size, size);
            i++;
            j--;
        }
    }
    if (j > low) {
        sort(ptr, low, j, size, cmp);
    }
    if (i < high) {
        sort(ptr, i, high, size, cmp);
    }
}

void my_qsort（常数void*ptr，大小计数，大小大小，整数（*cmp）（常数void*，常数void*））
{
排序（ptr，0，计数-1，大小，cmp）；
}
无效排序（常数无效*ptr、整数低、整数高、大小大小、整数（*cmp）（常数无效*、常数无效*）
{
int i=低；
int j=高；
字符*中间=（字符*）ptr+（（i+j）/2）*大小；
而（i问题的一部分来自只复制第一个字节的
swapper
函数。您可以将该函数重写为：

void swapper(void* x, void* y, size_t size)
{
    for(size_t i = 0; i < size; i++) {
        char tmp = ((char*)x)[i];
        ((char*)x)[i] = ((char*)y)[i];
        ((char*)y)[i] = tmp;
    }
}

void交换程序（void*x，void*y，size\u t size）
{
对于（大小i=0；i

这避免了内存分配。注意：在离开函数之前，内存没有被释放，因此它也造成了内存泄漏

问题的第二部分是在迭代时更改轴心。实现它的简单方法是使用找到的算法：

void排序（const void*ptr、int low、int high、size\u t size、int（*cmp）（const void*、const void*））
{
int i=低；
int j=高；
char*pivot=（char*）ptr+low*大小；
而（i低）{
排序（ptr，低，j-1，大小，cmp）；
}
如果（j+1<高）{
排序（ptr、j+1、高、大小、cmp）；
}
}
结果是什么，而不是排序列表？@ordoflamae，我得到了一个排序列表，但不完全。例如，我向您展示了数组的一部分：（正确排序）、85、46、52、92、93，（以及正确排序）。你能发布你的测试代码吗？我们需要一个@SkivHisink
swapper
函数只复制结尾的第一个字节。这可能是你问题的根源。此外，你分配内存，但从不释放内存。为了避免内存分配，我建议逐字节交换。@OrdoFlammae，我这样做了（但方法很简单）。
void sort(const void* ptr, int low, int high, size_t size, int (*cmp)(const void*, const void*))
{
    int i = low;
    int j = high;
    char* pivot = (char*)ptr + low * size;
    while (i < j)
    {
        while ((cmp((char*)ptr + i * size, pivot) <= 0)) {
            i++;
        }
        while (cmp((char*)ptr + j * size, pivot) > 0) {
            j--;
        }
        if (i < j) {
            swapper((char*)ptr + i * size, (char*)ptr + j * size, size);
        }
    }
    swapper(pivot, (char*)ptr + j * size, size);
    if (j-1 > low) {
        sort(ptr, low, j-1, size, cmp);
    }
    if (j+1 < high) {
        sort(ptr, j+1, high, size, cmp);
    }
}