排序-快速排序

typedef int (* Compare)(const void *key1, const void *key2);
static void OsNormalQuickSort(void *sort, unsigned int eleSize, int leftEnd, int rightEnd,
                              Compare compare, void *pivot, void *node)
{
    int i, j;
    char *out = (char *)sort;

    if (leftEnd >= rightEnd) {
        return;
    }

    i = leftEnd;
    j = rightEnd + 1;

    memcpy(pivot, &out[leftEnd * eleSize], eleSize);

    while (1) {
        do {
            j--;
            if (j <= leftEnd) {
                break;
            }
        } while (compare(&out[j * eleSize], pivot) >= 0);

        do {
            i++;
            if (i > rightEnd) {
                break;
            }
        } while (compare(&out[i * eleSize], pivot) <= 0);

        if (i >= j) {
            break;
        }
        memcpy(node, &out[i * eleSize], eleSize);
        memcpy(&out[i * eleSize], &out[j * eleSize], eleSize);
        memcpy(&out[j * eleSize], node, eleSize);
    }

    memcpy(&out[leftEnd * eleSize], &out[j * eleSize], eleSize);
    memcpy(&out[j * eleSize], pivot, eleSize);

    OsNormalQuickSort(sort, eleSize, leftEnd, j, compare, pivot, node);
    OsNormalQuickSort(sort, eleSize, j + 1, rightEnd, compare, pivot, node);

    return;
}

int QSort(void *sort, unsigned int eleSize, int size, Compare compare)
{
    void *pivot = NULL;
    void *node = NULL;

    if ((sort == NULL) || (eleSize == 0) || (compare == NULL) || (size == 0)) {
        return -1;
    }

    pivot = malloc(eleSize);
    if (pivot == NULL) {
        return -1;
    }

    node = malloc(eleSize);
    if (node == NULL) {
        return -1;
    }

    OsNormalQuickSort(sort, eleSize, 0, size - 1, compare, pivot, node);

    free(pivot);
    free(node);
    return 0;
}