不断出现分段错误：11 #包括 #包括 //树节点 typedef结构叶 { char ch； 国际频率； 结构叶*左，*右； }叶子； 类型定义结构节点{ int数据； 叶*leaf_数据； 结构节点*ptr； }节点； //-----链表----- 结构链接列表{ 节点*头； //节点*尾部； }; 类型定义结构链接列表链接列表； leaf*createLeaf（字符通道，整数频率） { 叶*节点=malloc（sizeof（叶））； 节点->ch=ch； 节点->频率=频率； 节点->左=空； 节点->右=空； 返回节点； } //-----创建链接列表----- LinkedList_s createSortedList（） { LinkedList_s list={NULL}； 退货清单； } 节点*createStackNode（叶*l）{ node*temp=（node*）malloc（sizeof（node））； 温度->数据=（内部）l->频率； 温度->叶数据=l； 返回温度； } 无效插入（链接列表头，节点*l）{ if（head->head==NULL）{ 头部->头部=l； } 否则如果（头部->头部->数据->l->数据）{ l->ptr=头部->头部； 头部->头部=l； } 否则{ node*prev=（node*）malloc（sizeof（node））； node*next=（node*）malloc（sizeof（node））； int i=0； prev=NULL； 下一步=头部->头部； while（next！=NULL&&i==0）{ 如果（下一步->数据>=l->数据）{ 上一个->ptr=l； l->ptr=next； i=1； } 上一个=下一个； 下一步=下一步->ptr； } if（next==NULL）{ 上一个->ptr=l； l->ptr=next； } } } 节点*出列（LinkedList_*列表）{ node*temp=（node*）malloc（sizeof（node））； 临时=列表->标题； 列表->头部=列表->头部->ptr； 返回温度； } void insertLeaf（链接列表，leaf*l）{ 节点*n=createStackNode（l）； //printf（“%d”，n->data）； 插入（列表，n）； }

基本上，我正在为一个类项目构建一个huffman编码器，并尝试创建一个排序列表/优先级队列，以按频率顺序存储BTS叶节点。我在createStackNode上遇到问题。如果将节点结构int data更改为int*data，则不会得到seg。故障，但这样它会随机分离。错误，无法排序。任何想法都将不胜感激

所以我从一个单独的文件调用insertLeft

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

// A Tree node
typedef struct leaf
{
    char ch;
    int freq;
    struct leaf *left, *right;
}leaf;

typedef struct node{
    int data;
    leaf* leaf_data;
    struct node *ptr;
} node;

//----- LINKED LIST -----
struct LinkedList {
   node* head;
   //node* tail;
};
typedef struct LinkedList LinkedList_s;


leaf* createLeaf(char ch, int freq)
{
    leaf* node = malloc(sizeof(leaf));

    node->ch = ch;
    node->freq = freq;
    node->left = NULL;
    node->right= NULL;
    return node;
}

//----- CREATE LINKED LIST -----
LinkedList_s createSortedList()
{
   LinkedList_s list = {NULL};
   return list;
}

node* createStackNode(leaf* l){
    node* temp = (node*) malloc(sizeof(node)) ;
    temp->data = (int) l->freq;

    temp->leaf_data = l;

    return temp;
}


void insert(LinkedList_s* head, node* l) {
    

    if(head->head == NULL){
        head->head = l;
    }
    else if (head->head->data > l->data){
        l->ptr = head->head;
        head->head = l;
    }
    else{
    node *prev = (node*)malloc(sizeof(node));
    node *next = (node*)malloc(sizeof(node));
    int i = 0;

    prev = NULL;
    next = head->head;
    while(next != NULL && i == 0){
       
        if (next->data >= l->data){
            prev->ptr = l;
            l->ptr = next;
            i = 1;
        }
        prev = next;
        next = next->ptr;
    }
    if (next == NULL){
        prev->ptr = l;
        l->ptr = next;
    }
   
    
    }

}


node* dequeue(LinkedList_s *list){
    node* temp = (node*)malloc(sizeof(node));
    temp = list->head;
    list->head = list->head->ptr;

    return temp;
}

void insertLeaf(LinkedList_s *list, leaf* l){
    node* n = createStackNode(l);
    //printf("%d", n->data);
    insert(list, n);
}

#包括
#包括
#包括“排序列表.h”
#包括“链接计数器.h”
内部主（空）{
//列一个频率表
LinkedList_t*x=malloc（sizeof（LinkedList_t））；
x=makeList（）；
//创建已排序的列表/优先级队列
struct LinkedList_s*list=malloc（sizeof（LinkedList_s））；
*list=createSortedList（）；
叶*l=malloc（叶的大小）；
//用于遍历的当前节点
Node_t*current=malloc（sizeof（Node_t））；
电流=x->head；
while（当前！=NULL）{
l=createLeaf（当前->数据，当前->计数）；
printf（“%c%d->”，l->ch，l->freq）；
插入叶（列表，l）；
当前=当前->下一步；
}
//对于（int i=0；i<5；i++）
//printf（“%c~~\n”，list->head->leaf\u data->ch）；
}

---

在insert leaf时，它给出错误

使用调试器运行代码。当遇到故障时，它将停止。您可以从那里追溯并检查导致故障发生的条件。您的插入非常复杂。获取准备好的节点的插入函数需要两行。下面是一个可以获取任何类型数据的链表实现示例。看看它是多么简洁和简单：

main

做的第一件事就是调用

malloc

，将结果存储在

x

中。它做的第二件事是调用

makeList

，将结果赋值给

x

，并丢弃

malloc

返回的值。因此，（1）调用

malloc

是无用的，（2）这是一个内存泄漏（一个bug）。同样的情况也会发生在下面的

current

中。提示：

x=foo（）；x=y

相当于

（void）foo（）；x=y。换句话说，调用
foo
的结果将丢失。
#include <stdio.h>
#include <stdlib.h>

#include "Sorted_List.h"
#include "linked_counter.h"


int main(void){
    //Make a Frequency List
    LinkedList_t* x = malloc(sizeof(LinkedList_t));
    x = makeList();

    //Create a Sorted List/Priority Queue
    struct LinkedList_s* list = malloc(sizeof(LinkedList_s));
    *list = createSortedList();
    leaf* l = malloc(sizeof(leaf));

    //Current node for traversal 
    Node_t* current = malloc(sizeof(Node_t));
    current= x->head;
    
    
    while(current != NULL){

        l = createLeaf(current->data, current->count);
        printf("%c %d  ->",l->ch, l->freq);
        insertLeaf(list, l);

        current= current->next;
    }

    //for(int i = 0; i < 5; i++)
        //printf("%c~~\n", list->head->leaf_data->ch);
}