Question

我有一个通用的快速排序功能：

void qsort(void* sup,int n,
 int(*cmp) (void *x,void *y),
  void (*swap) (void *a,void *b))
{
 int pv=n/2,l=0,h=n-1;

 if(n<2)
  return;

 while(h-1>=l)
 {
  if(l==pv)
  {
   swap(sup+pv,sup+pv+1);
   pv++;
  }
  if(h==pv)
  {
   swap(sup+pv,sup+(pv-1));
   pv--;
  }
  if(cmp(sup+h, sup+pv))
  {
   h--;
   continue;
  }
  if(cmp(sup+pv, sup+l))
  {
   l++;
   continue;
  }
  swap(sup+l,sup+h);
  l++,h--;
 }
 qsort(sup, l, cmp, swap);
 qsort(sup+l,n-l, cmp, swap);
}

将这些函数作为参数：

int cmp(int *c1, int *c2) {
 return *c1 > *c2;
}

void swap(int *a,int *b)
{
 int c= *a;
 *a=*b;
 *b=c;
}

主要功能如下：

int main()
{
 int arr[4] = {3,4,1,2};
 print(arr, 4);
 printf("\n\n");
 qsort(arr, 4, &cmp, &swap);
 print(arr, 4);
 return 0;
}

其中print是：

void print(int* arr, int size) {
 int i = 0;
 for(; i < size; ++i) {
  printf("%d \t", arr[i]);
 }
}

问题：

当qsort的原型是：

时

void qsort(int* sup,int n,
 int(*cmp) (void *x,void *y),
  void (*swap) (void *a,void *b))

效果很好，

但是当我将sup参数更改为void*时：

void qsort(void* sup,int n,
 int(*cmp) (void *x,void *y),
  void (*swap) (void *a,void *b))

它不起作用。有谁知道为什么？

我在Windows下使用Code :: Blocks，使用MinGW。

Answer 1

您必须能够取消引用您的参数。 void*无法解除引用，因为编译器无法确定您传递的类型。如果您通过void*，则必须使用显式转换。

此

void qsort(int* sup,int n,
 int(*cmp) (void *x,void *y),
  void (*swap) (void *a,void *b))

绝对没问题，但这里

void qsort(void* sup,int n,
 int(*cmp) (void *x,void *y),
  void (*swap) (void *a,void *b))

你传递的是void*（sup），但这个不能被解除引用。所以你的第一个解决方案很好，但你必须在(*cmp)中进行类型转换或为每种类型定义一个qsort。

Answer 2

以下是修复排序的方法：

#include <stdio.h>

void Qsort(
  void* sup,
  int n,
  int size,
  int(*cmp) (const void *x, const void *y),
  void (*swap) (void *a,void *b))
{
  int pv = n / 2, l = 0, h = n - 1;

  if (n < 2)
    return;

  while (h - 1 >= l)
  {
    if (l == pv)
    {
      swap((char*)sup + pv * size, (char*)sup + (pv + 1) * size);
      pv++;
    }

    if(h == pv)
    {
      swap((char*)sup + pv * size, (char*)sup + (pv - 1) * size);
      pv--;
    }

    if (cmp((char*)sup + h * size, (char*)sup + pv * size) > 0)
    {
      h--;
      continue;
    }

    if (cmp((char*)sup + pv * size, (char*)sup + l * size) > 0)
    {
      l++;
      continue;
    }

    swap((char*)sup + l * size, (char*)sup + h * size);
    l++, h--;
  }

  Qsort(sup, l, size, cmp, swap);
  Qsort((char*)sup + l * size, n - l, size, cmp, swap);
}

int cmp(const void *c1, const void *c2)
{
  int a = *(const int*)c1;
  int b = *(const int*)c2;
  if (a > b) return 1;
  if (a < b) return -1;
  return 0;
}

void swap(void *c1, void *c2)
{
  int c = *(int*)c1;
  *(int*)c1 = *(int*)c2;
  *(int*)c2 = c;
}

void print(int* arr, int size)
{
  int i = 0;
  for(; i < size; ++i)
  {
    printf("%d \t", arr[i]);
  }
}

int main(void)
{
  int arr[4] = {3,4,1,2};
  print(arr, 4);
  printf("\n\n");
  Qsort(arr, 4, sizeof(arr[0]), &cmp, &swap);
  print(arr, 4);
  return 0;
}

输出（ideone）：

3       4       1       2

1       2       3       4

请注意，以与标准库函数相同的方式命名函数是一件坏事。您的程序可能无法编译或工作。出于这个原因，我将qsort更改为Qsort。

Answer 3

我们可以改进通用快速排序以省略交换功能。

#ifdef _WIN32
#define alloca _alloca
#else
#include <alloca.h>
#endif

// the generic swap function
void arrswap(void * const a, void * const b, int const sz) {
    int64_t tmp;
    void * p;
    bool needfree = false;
    if (sz > sizeof(int64_t)) {
        p = alloca(sz);
        if (p == NULL) {
            p = malloc(sz);
            //assert(p != NULL, "not enough memory");
            needfree = true;
        }
    }
    else {
        p = &tmp;
    }

    memcpy(p, b, sz);
    memcpy(b, a, sz);
    memcpy(a, p, sz);

    if (needfree) {
        free(p);
    }

}
// O(n^2) sort
void arrsort(void * const p, int const sz, int const n,
    int(*compare)(void const * const pa, void const *const pb)) {

    for (int i = 0; i < n; i++) {
        for (int j = i + 1; j < n; j++) {
            if (compare((char*)p + i*sz, (char*)p + j*sz) == 1) {
                arrswap((char*)p + i*sz, (char*)p + j*sz, sz);
            }
        }
    }
}

// guess the index of the pivot value from three value in the array.
static int guessmidval(void * const p, int const sz, int const n,
    int(*compare)(void const * const pa, void const *const pb)) {

    int a = 0;
    int b = n / 2;
    int c = n - 1;

    int ab = compare((char*)p + a*sz, (char*)p + b*sz);
    int bc = compare((char*)p + b*sz, (char*)p + c*sz);
    int cb = compare((char*)p + c*sz, (char*)p + b*sz);
    int ba = compare((char*)p + b*sz, (char*)p + a*sz);
    if (ab <= 0 && bc <= 0 || cb <= 0 && ba <= 0) {
        return b;
    }

    int ac = compare((char*)p + a*sz, (char*)p + c*sz);
    int ca = compare((char*)p + c*sz, (char*)p + a*sz);
    if (ba <= 0 && ac <= 0 || ca <= 0 && ab <= 0) {
        return a;
    }

    return c;
}
// quick sort
void arrqsort(void * const p, int sz, int const n,
    int(*compare)(void const * const pa, void const *const pb)) {

    if (n <= 2) {
        arrsort(p, sz, n, compare);
        return;
    }

    int midval_index = guessmidval(p, sz, n, compare);
    arrswap(p, (char*)p + midval_index*sz, sz);

    int i, j;
    for (i = 1, j = n - 1; ; i++, j--) {
        for (; compare((char*)p + i*sz, p) <= -1 && i <= j; i++);
        for (; compare((char*)p + j*sz, p) >= +1 && i <= j; j--);
        if (i >= j)break;
        arrswap((char*)p + i*sz, (char*)p + j*sz, sz);
    }
    arrqsort(p, sz, i, compare);
    arrqsort((char*)p + i*sz, sz, n - i, compare);
}

为int64创建比较函数：

int compare_int64(void const * const pa, void const *const pb) {
    int64_t a = *(int64_t*)pa;
    int64_t b = *(int64_t*)pb;
    if (a > b)return 1;
    else if (a < b)return -1;
    return 0;
}

我们可以像arrqsort一样打电话：

int64_t a[] = { 3,1,65,4,-1 };
int n = sizeof(a) / sizeof(*a);
arrqsort(a, sizeof(*a), n, compare_int64);
for (int j = 0; j < n; j++) {//-1,1,3,4,65,
    printf("%d,", a[j]);
}

通用quicksort适用于int ，但不适用于void

3 个答案:

通用quicksort适用于int *，但不适用于void *

3 个答案:

通用quicksort适用于int ，但不适用于void