如何创建一个 qsort 函数并对指向结构的指针数组进行排序

Question

我正在尝试从头开始创建一个 qsort 函数，该函数对指向结构的指针数组进行排序

这是我现在的代码

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

void _qsort(void* list, int list_len, int left, int right, 
            int(*comp)(const struct shpg_item *a, const struct shpg_item *b)) {
  void *vt, *v3; 
  int i, last, mid = (left + right) / 2; 
  if (left >= right) 
    return; 

  void* vl = (char*)(list + (left * list_len)); 
  void* vr = (char*)(list + (mid * list_len)); 
  swap(vl, vr); 
  last = left; 
  for (i = left + 1; i <= right; i++) { 

    // vl and vt will have the starting address  
    // of the elements which will be passed to  
    // comp function. 
    vt = (char*)(list + (i * list_len)); 
    if ((*comp)(vl, vt) > 0) { 
      ++last; 
      v3 = (char*)(list + (last * list_len)); 
      swap(vt, v3); 
    } 
  } 
  v3 = (char*)(list + (last * list_len)); 
  swap(vl, v3); 
  _qsort(list,list_len, left, last - 1, comp);
  trace_int(1);
  _qsort(list, list_len, last + 1, right, comp); 
}

void list_sort(struct shpg_item **list, int list_len,
               int(*comp)(const struct shpg_item *a, const struct shpg_item *b)) {
  _qsort(*list,list_len,0,(list_len-1),comp);
}

但这给出了分段错误错误，谁能告诉我为什么并帮助我？

Answer 1

我没有检查整个代码，但您的交换功能似乎有误。取决于代码中的注释行；

// vl and vt will have the starting address  
// of the elements which will be passed to  
// comp function. 

如果 (list + (left * list_len)) 和 (list + (last * list_len)) 是要交换的指针（例如指向字符串或结构的指针），则交换函数装饰和调用者行应为：

1. 交换两个整数、浮点数、双精度值等（通常仅交换值）：

void swap(int *a, int *b) {
    int t = *a;
    *a = *b;
    *b = t;
}
...
int x = 5;
int y = 3;
swap(&x, &y);

1. 如果您需要交换两个指针（char * 字符串或指向结构的其他类型的指针），您可以只交换指针值而不交换实际内存中指向的内容：

void swap(void **a, void **b) {
    void *t = *a;
    *a = *b;
    *b = t;
}
...
char *x = "some string";
char *y = "some other string";
swap(&x, &y);

Answer 2

void *指针加法

void * 指针添加是未定义的行为。但是由于通常的UB是可以的，这可能是也可能不是OP的麻烦。

void _qsort(void* list, int list_len, int left, ...
    ...
    (list + (left * list_len))  // UB

建议在添加之前进行强制转换。

// void* vl = (char*)(list + (left * list_len)); 
void* vl = ((char*) list) + (left * list_len); 

可能存在其他问题

Answer 3

我在这个答案的中间部分包含了一个工作示例，并且还添加了一个使用 qsort 的示例。

快速查看我在这里看到问题的代码：

void _qsort(void* list, ...

既然列表是一个指针数组，它应该是：

void _qsort(void** list, ...

或

void _qsort(void* list[], ...

有了这个声明，指针运算就不会成为问题，例如，list+3 == &list[3] == 指向数组中第三个指针的指针。不需要强制转换列表，因为 void** list 在代码的主要部分可以正常工作。唯一可以进行任何转换的代码是调用者的比较函数。

你可以选择使用type void **来模拟qsort的比较函数参数：compare(list+i, list+j)，但是使用type void *会更简单：compare(list[i], list[j ])。

Swap 应该使用 void** 作为参数。电话将是

    swap(list+i, list+j)

/*   ... */

void swap(void **i, void **j){
void * t;
    t = *i;
    *i = *j;
    *j = t;
}

---

有一些关于 void 指针的 cmets 可能具有与结构指针或任何类型的数据指针不同的大小，这可能会导致问题。如果这是真的，那么 C 库函数 qsort() 将不起作用，因为 qsort 的第一个参数是一个 void 指针，这将导致调用者的指针被强制转换为一个 void 指针。在调用者的比较函数中，两个参数都是 const void 指针，调用者的比较函数必须将其转换为实际的指针类型。使用 qsort() 和调用者的比较函数，参数可以毫无问题地与 void 指针相互转换。

C 保证 void 指针可用于保存任何类型的数据指针，因此本质上 void 指针是通用数据指针（在 16 位段或选择器环境中，通用“近”数据指针）。

---

这是一个工作示例，使用典型的 Lomuto 分区方案 (pivot = a[hi])：

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

typedef struct {
    int  data;
    char name[32];
}XMPL;

int cmpr(void * pi, void *pj)
{
    if(((XMPL *)pi)->data < ((XMPL *)pj)->data)
        return -1;
    if(((XMPL *)pi)->data > ((XMPL *)pj)->data)
        return  1;
    return 0;
}

void swap(void **i, void **j){
void * t;
    t = *i;
    *i = *j;
    *j = t;
}

void QuickSort(void **a, int lo, int hi, int(*cmpp)(void *, void *))
{
void *p;
int i, j;

    while(lo < hi){
        p = a[hi];
        i = lo;
        for(j = lo; j < hi; ++j){
            if((cmpp(a[j], p) < 0)){
                swap(a+i, a+j);
                ++i;
            }
        }
        swap(a+i, a+hi);
        if(i - lo <= hi - i){           /* avoid stack overflow */
            QuickSort(a, lo, i-1, cmpp);
            lo = i+1;
        } else {
            QuickSort(a, i+1, hi, cmpp);
            hi = i-1;
        }
    }
}

#define COUNT (1024)

int main(int argc, char**argv)
{
XMPL *ax;                               /* array of structures */
XMPL **pax;                             /* array of pointers to structures */
int i;

    ax =  malloc(COUNT * sizeof(XMPL));
    pax = malloc(COUNT * sizeof(void **));

    for(i = 0; i < COUNT; i++){         /* init structs, array of ptrs */
        ax[i].data = rand();
        pax[i] = ax+i;
    }

    QuickSort(pax, 0, COUNT-1, cmpr);

    for(i = 1; i < COUNT; i++){
        if(pax[i-1]->data > pax[i]->data){
            break;
        }
    }
    if(i == COUNT)
        printf("passed\n");
    else
        printf("failed\n");
    
    free(pax);
    free(ax);

    return(0);
}

---

Hoare 分区方案可能会快一点。但是，在这种情况下，归并排序应该比快速排序更快。与快速排序相比，合并排序的移动次数更多，但比较次数更少，在这种情况下，只有指针被移动，而比较涉及通过指针的间接寻址和通过指针对比较函数的调用。

---

相同的基本代码，但使用 qsort。请注意，cmpr() 函数需要对每个参数再取消引用。

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

typedef struct {
    int  data;
    char name[32];
}XMPL;

int cmpr(const void * pi, const void *pj)
{
    if((*(XMPL **)pi)->data < (*(XMPL **)pj)->data)
        return -1;
    if((*(XMPL **)pi)->data > (*(XMPL **)pj)->data)
        return  1;
    return 0;
}

#define COUNT (1024)

int main(int argc, char**argv)
{
XMPL *ax;                               /* array of structures */
XMPL **pax;                             /* array of pointers to structures */
int i;

    ax =  malloc(COUNT * sizeof(XMPL));
    pax = malloc(COUNT * sizeof(void **));

    for(i = 0; i < COUNT; i++){         /* init structs, array of ptrs */
        ax[i].data = rand();
        pax[i] = ax+i;
    }

    qsort(pax, COUNT, sizeof(XMPL *), cmpr);

    for(i = 1; i < COUNT; i++){
        if(pax[i-1]->data > pax[i]->data){
            break;
        }
    }
    if(i == COUNT)
        printf("passed\n");
    else
        printf("failed\n");
    
    free(pax);
    free(ax);

    return(0);
}