Question

实际上我必须创建霍夫曼树，我需要对频率进行排序，我正在使用qsort（）函数。但是，当我尝试显示频率时，它仍显示相同的模式（不是排序的模式）。这是我的代码： -

        struct node
        {
            int value;
            char letter;                 /* symbol */
            struct node *left,*right;    /* left and right subtrees */
        };
    typedef struct node Node;
//Given below is the frequency of all 27 alphabets
int englishLetterFrequencies [27] = {81, 15, 28, 43, 128, 23, 20, 61, 71, 2, 1, 40, 24, 69, 76, 20, 1, 61, 64, 91, 28, 10, 24, 1, 20, 1, 130};

这是我的函数，我尝试构建huffman（它在main（）中）：

/*builds the huffman tree and returns its address by reference*/

    void buildHuffmanTree(Node **tree){
        Node *temp;
        Node *array[27];
        int i, subTrees = 27;
        int smallOne;

        for (i=0;i<27;i++)
        {
            array[i] = malloc(sizeof(Node));
            array[i]->value = englishLetterFrequencies[i];
            array[i]->letter = i;
            array[i]->left = NULL;
            array[i]->right = NULL;
        }
         smallOne=sorting(array); //this function is responsible for sorting. I HAVE QSORT() CALL IN THIS FUNCTION

    return;
}

查看其功能定义：

int sorting(Node *array[])
{
    int smaller;
    int i = 0; int d,p;
    printf("the array frequency is \n");
    for(d=0;d < 27;d++)
    printf("%d  ",*array[d]);
    // sorting of arrays
    qsort(array,27,sizeof(*array),&cmpfunc); 
    //////////////////////////
    printf("\n the sorted array frequency is \n");
        for(p=0;p < 27;p++)
    printf("%d  ",*array[p]);

    return smaller;
}

而cmpfunc（）就像这样//可疑的错误就在这里

 int cmpfunc (const void * a, const void * b)
    {
          return ( ((Node *)a)->value - ((Node *)b)->value );
    }

知道为什么不对数组进行排序吗？

Answer 1

 return ( (*(int**)a) - (*(int**)b ));

这是将a和b作为“指向指针指向int”的指针，因此只需解除引用它们一次，然后计算两个指针之间的差异。你的意思是：

 return ( (*(Node **)a)->value - (*(Node **)b)->value );

因为虽然**(int**)a可能在这种情况下起作用，但大量会让任何试图理解代码的人感到困惑。

编辑：抱歉，我最后错过了自己的解除引用 - 修复。

此外：

printf("%d  ",*array[d]);

应该是

printf("%d  ",array[d]->value);

出于同样的原因。

Answer 2

你的比较器是错误的，你对qsort如何运作的假设并不遥远。

为了对Node*的指针数组进行排序，你需要一个像这样的比较器：

int cmpfunc (const void * a, const void * b)
{
    const Node **lhs = (const Node **)a;
    const Node **rhs = (const Node **)b;
    return (*lhs)->value < (*rhs)->value ? -1
        : ((*rhs)->value < (*lhs)->value ? 1 : 0);
}

删除所有无关的垃圾，包括sorting()调用并直接调用qsort ...

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

struct node
{
    int value;
    char letter;                 /* symbol */
    struct node *left,*right;    /* left and right subtrees */
};
typedef struct node Node;

static const int englishLetterFrequencies [27] =
{
    81, 15, 28, 43, 128, 23,
    20, 61, 71, 2, 1, 40, 24,
    69, 76, 20, 1, 61, 64, 91,
    28, 10, 24, 1, 20, 1, 130
};

int cmpfunc (const void * a, const void * b)
{
    const Node **lhs = (const Node **)a;
    const Node **rhs = (const Node **)b;
    return (*lhs)->value < (*rhs)->value ? -1
        : ((*rhs)->value < (*lhs)->value ? 1 : 0);
}

void buildHuffmanTree(Node **tree)
{
    Node *array[27];
    int i;

    for (i=0;i<27;i++)
    {
        array[i] = malloc(sizeof(*array[i]));
        array[i]->value = englishLetterFrequencies[i];
        array[i]->letter = (char)i;
        array[i]->left = NULL;
        array[i]->right = NULL;
    }

    qsort(array, 27, sizeof(*array), cmpfunc);

    for (i=0; i<27; ++i)
        printf("array[%d]->value = %d\n", i, array[i]->value);

    return;
}

int main()
{
    buildHuffmanTree(NULL);
    return 0;
}

<强>输出

array[0]->value = 1
array[1]->value = 1
array[2]->value = 1
array[3]->value = 1
array[4]->value = 2
array[5]->value = 10
array[6]->value = 15
array[7]->value = 20
array[8]->value = 20
array[9]->value = 20
array[10]->value = 23
array[11]->value = 24
array[12]->value = 24
array[13]->value = 28
array[14]->value = 28
array[15]->value = 40
array[16]->value = 43
array[17]->value = 61
array[18]->value = 61
array[19]->value = 64
array[20]->value = 69
array[21]->value = 71
array[22]->value = 76
array[23]->value = 81
array[24]->value = 91
array[25]->value = 128
array[26]->value = 130

花些时间学习算法的工作原理，不要走捷径。您将需要两个比较器函数来完成您最终要做的事情（假设我了解您计划如何构建您的霍夫曼树）。

qsort（）不适用于数组数组

2 个答案: