指针分配的指针分段错误

Question

我正在实现霍夫曼压缩，并且我正在从包含节点的链接列表构建一个 hufftree。多次迭代后，我在指向分配指针的指针上出现分段错误。根据我的经验和研究，我认为分段错误是由于程序中断以外的错误引起的。任何帮助或建议将不胜感激。

P.S - 我是堆栈溢出的新手，以前从未问过问题，所以如果您需要更多信息来帮助我解决这个问题或其他任何问题，请告诉我。

struct LinkList{
    int weight;
    struct TreeNode * bottom;
    struct LinkList * next;
}; typedef struct LinkList LinkList;

//This function takes in a link list where each node points to the next
 //element in the link list and a huff tree node. It also contains weight 
//which is equal to the weight of the hufftree that it points to.

TreeNode * huffTree(LinkList * head)
{
    LinkList * temphead = head;
    LinkList * ptr;
    LinkList * ptr1;
    int count = 127,i;
    while(count>2)
    {
        temphead = head->next->next;
        head->next->next = NULL;
        head = mergeTree(head);
        ptr = temphead;
        ptr1 = temphead;// This is where I get the segmentation fault
//when the value of count is 14
        while(head->weight>temphead->weight)
        {
            ptr1 = temphead;
            temphead = temphead->next;
        }

        if(ptr1!=temphead)
        {
            head->next = temphead;
            ptr1->next = head;
            head = ptr;
        }

        else
        {
            head->next = temphead;
        }

        count--;
    }

    head = mergeTree(head);

    TreeNode * root;
    root = head->bottom;
    head->bottom = NULL;
    free(head);
    return root;
}

LinkList * mergeTree(LinkList * head)
{
    TreeNode * tree1 = head->bottom;
    TreeNode * tree2 = head->next->bottom;
    head->bottom = NULL;
    head->next->bottom = NULL;

    free(head->next);
    free(head);

    TreeNode * newnode = (TreeNode *) malloc(sizeof(TreeNode));

    newnode->weight = tree1->weight + tree2->weight;
    newnode->c = '~';
    newnode->left = tree1;
    newnode->right = tree2;

    LinkList * ptr = (LinkList *) malloc(sizeof(TreeNode));
    ptr->weight = newnode->weight;
    ptr->bottom = newnode;
    ptr->next = NULL;

    return ptr;
}

Answer 1

我的猜测是声明“while(head->weight>temphead->weight) {}”。 当您遍历列表时，您还没有检查头部是否变为 NULL。

Answer 2

在您的“huffTree()”函数中，外部 while 循环 (while (count > 2)) 运行了 127 次迭代，因为 count 被初始化为 129。

因此，当调用者调用 huffTree() 时，输入列表 (LinkList *head) 必须有 129 个可用节点。

无论如何，如果列表中的节点少于 129 个，则应添加以下 NULL 条件处理。

temphead = head->next->next;
if (NULL == temphead)
{
    /* NULL condition handling */
}

当 temphead == NULL 时，则 temphead->权重取消引用将导致以下代码行中的分段错误

while(head->weight>temphead->weight)

head->如果保证 malloc() 在 mergeTree() 函数中不会失败，则权重很好。