C 使用最小堆构建哈夫曼树

我在建造哈夫曼树时遇到了一些问题。在构建哈夫曼树时，我使用min-heap来实现。我认为min heap的代码工作得很好，但是当我运行building huffman树代码时，出现了错误。我已经研究了很长时间，但我没有办法解决它。希望有人能帮助我解决我的问题。代码如下：

#include <stdio.h>
#include <stdlib.h>
#define MaxSize 100
#define MaxData NULL

// Huffman tree的建树过程用最小堆时因为每次都可以挑出最小的两个元素组成

typedef struct TreeNode {
    int weight;
    struct TreeNode *left;
    struct TreeNode *right;
}HuffmanTree;

typedef struct HeapStruct {
    HuffmanTree *Elements[MaxSize+1];      // an array
    int Size;      // the number of item in array
    int Capacity;      /* the capacity of heap */
}MinHeap;



MinHeap *Create()
{   // create a empty heap
    MinHeap *H;
    H = (MinHeap *)malloc(sizeof(MinHeap));
    H->Elements[0] = NULL;
    H->Size = 0;
    H->Capacity = MaxSize;
    return H;
}

int isFull(MinHeap *H) 
{   // judge the heap full or not 
    return (H->Size == MaxSize);
}

int isEmpty(MinHeap *H)
{   // judge the heap empty or not
    return (H->Size == 0);
} 

void Add(MinHeap *H, int item)
{   // add item to the array
    if( isFull(H) )
    {
        printf("the heap is full.\n");
        return;
    }
    HuffmanTree *T;
    T = (HuffmanTree *)malloc(sizeof(HuffmanTree));
    T->weight = item;
    H->Elements[++(H->Size)] = T;
    return;
}

void Insert(MinHeap *H, HuffmanTree *item)
{   // insert item 
    int i;
    if( isFull(H) )
    {
        printf("the heap is full.\n");
        return;
    }
    i = ++(H->Size);
    for(; (H->Elements[i/2]->weight)>(item->weight);i/=2)
        H->Elements[i] = H->Elements[i/2];
    H->Elements[i] = item;
}

HuffmanTree *DeleteMin(MinHeap *H)
{   // delete item of the heap
    int Parent, Child;
    HuffmanTree *MinValueNode, *tempNode;
    if( isEmpty(H) )
    {
        printf("the heap is empty.\n");
        return NULL;
    }
    MinValueNode = H->Elements[1];
    tempNode = H->Elements[H->Size--];
    for(Parent=1; Parent*2<=H->Size; Parent=Child)
    {
        Child = Parent * 2;
        if( (Child != H->Size) && (H->Elements[Child]->weight > H->Elements[Child+1]->weight) )
            Child++;
        if( tempNode->weight <= H->Elements[Child]->weight )
            break;
        else 
            H->Elements[Parent] = H->Elements[Child];
    } 
    H->Elements[Parent] = tempNode;
    return MinValueNode; 
}

void PercDown(MinHeap *H, int i)
{   // adjustment of the heap 
    int Parent, Child;
    HuffmanTree *temp;
    temp = H->Elements[i];
    for(Parent=i; Parent*2<=H->Size; Parent=Child)
    {
        Child = Parent * 2;
        if( (Child != H->Size) && (H->Elements[Child]->weight > H->Elements[Child+1]->weight) )
            Child++;      // Child point to the min 
        if( temp->weight <= H->Elements[Child]->weight )    
            break;
        else        
            H->Elements[Parent] = H->Elements[Child];      
    }
    H->Elements[Parent] = temp;
}

void BuildMinHeap(MinHeap *H)
{ 
    int i;
    for(i=H->Size/2; i>0; i--)
        PercDown(H, i);
    return;
}

HuffmanTree *Huffman(MinHeap *H)
{   /* Assuming that H->Size weight hava existed in H->Elements[]->weight */
    int i;
    HuffmanTree *T;

    BuildMinHeap( H );     // adjustment 
    for(i=1; i<H->Size; i++)      // merge H->Size-1  
    {
        T = (HuffmanTree *)malloc(sizeof(HuffmanTree));      
        T->left = DeleteMin( H );      
        T->right = DeleteMin( H );     
        T->weight = T->left->weight + T->right->weight;     
        Insert(H, T); 
    }
    T = DeleteMin( H );
    return T;
}

void print_heap(MinHeap *H)
{
    if( isEmpty(H) )
    {
        printf("the heap is empty.\n");
        return;
    }
    for(int i=1; i<=H->Size; i++)
        printf("%d   ", H->Elements[i]->weight);
    printf("\n");
} 

void print_tree(HuffmanTree *T)
{
    if( T )
    {
        print_tree(T->left);
        printf("%d ", T->weight);
        print_tree(T->right);
    }
    return;
}

int main()
{
    MinHeap *heap;
    HuffmanTree *HT, *T;
    heap = Create();
    int x;
    printf("please input data:\n");
    scanf("%d", &x);
    while( x )
    {
        Add(heap, x);
        scanf("%d", &x);
    }   
    printf("original items:\n");
    print_heap( heap );
    printf("the item number of heap%d\n", heap->Size);
    BuildMinHeap(heap);
    print_heap( heap );
    HT = DeleteMin( heap );
    printf("删除的结点的值为%d\n", HT->weight);
    print_heap( heap );
    HT = Huffman( heap );
    print_tree( HT );
    return 0; 
}

#包括
#包括
#定义最大尺寸100
#定义MaxData NULL
//哈夫曼树的建树过程用最小堆时因为每次都可以挑出最小的两个元素组成
类型定义结构树节点{
整数权重；
结构树节点*左；
结构树节点*右侧；
}赫夫曼特里；
类型定义结构HeapStruct{
HuffmanTree*元素[MaxSize+1]；//数组
int Size；//数组中的项数
int Capacity；/*堆的容量*/
}肉堆；
MinHeap*Create（）
{//创建一个空堆
MinHeap*H；
H=（MinHeap*）malloc（sizeof（MinHeap））；
H->Elements[0]=NULL；
H->Size=0；
H->容量=最大尺寸；
返回H；
}
int为满（最小堆*H）
{//判断堆是否已满
返回值（H->Size==MaxSize）；
}
int isEmpty（MinHeap*H）
{//判断堆是否为空
返回值（H->Size==0）；
} 
void Add（MinHeap*H，int项）
{//将项添加到数组中
如果（已满（H））
{
printf（“堆已满。\n”）；
返回；
}
赫夫曼特里*T；
T=（哈夫曼特里*）malloc（sizeof（哈夫曼特里））；
T->重量=物品；
H->元素[++（H->尺寸）]=T；
返回；
}
无效插入（MinHeap*H，HuffmanTree*item）
{//插入项目
int i；
如果（已满（H））
{
printf（“堆已满。\n”）；
返回；
}
i=++（H->尺寸）；
对于（；（H->元素[i/2]->重量）>（项目->重量）；i/=2）
H->元素[i]=H->元素[i/2]；
H->元素[i]=物料；
}
HuffmanTree*DeleteMin（MinHeap*H）
{//删除堆中的项
int父、子；
HuffmanTree*MinValueNode，*tempNode；
if（isEmpty（H））
{
printf（“堆是空的。\n”）；
返回NULL；
}
MinValueNode=H->元素[1]；
tempNode=H->Elements[H->Size--]；
对于（父项=1；父项*2大小；父项=子项）
{
子=父*2；
if（（Child！=H->Size）&&（H->Elements[Child]->weight>H->Elements[Child+1]->weight））
儿童++；
if（tempNode->weight Elements[Child]->weight）
打破
其他的
H->Elements[Parent]=H->Elements[Child]；
} 
H->Elements[Parent]=tempNode；
返回MinValueNode；
}
void PercDown（MinHeap*H，int i）
{//堆的调整
int父、子；
赫夫曼特里*温度；
temp=H->Elements[i]；
对于（父项=i；父项*2大小；父项=子项）
{
子=父*2；
if（（Child！=H->Size）&&（H->Elements[Child]->weight>H->Elements[Child+1]->weight））
Child++；//Child指向最小值
if（临时->权重元素[子项]->权重）
打破
其他的
H->Elements[Parent]=H->Elements[Child]；
}
H->元素[父元素]=温度；
}
void BuildMinHeap（MinHeap*H）
{ 
int i；
对于（i=H->Size/2；i>0；i--）
PercDown（H，i）；
返回；
}
哈夫曼树*哈夫曼（MinHeap*H）
{/*假设H->Size-weight hava存在于H->Elements[]->weight中*/
int i；
赫夫曼特里*T；
BuildMinHeap（H）；//调整
对于（i=1；iSize；i++）//合并H->Size-1
{
T=（哈夫曼特里*）malloc（sizeof（哈夫曼特里））；
T->left=DeleteMin（H）；
T->right=DeleteMin（H）；
T->weight=T->left->weight+T->right->weight；
插入（H，T）；
}
T=DeleteMin（H）；
返回T；
}
无效打印堆（最小堆*H）
{
if（isEmpty（H））
{
printf（“堆是空的。\n”）；
返回；
}
for（int i=1；iSize；i++）
printf（“%d”，H->Elements[i]->权重）；
printf（“\n”）；
} 
无效打印树（HuffmanTree*T）
{
if（T）
{
打印树（T->左）；
printf（“%d”，T->重量）；
打印树（T->右）；
}
返回；
}
int main（）
{
MinHeap*heap；
赫夫曼树*HT，*T；
heap=Create（）；
int x；
printf（“请输入数据：\n”）；
scanf（“%d”和&x）；
while（x）
{
添加（堆，x）；
scanf（“%d”和&x）；
}   
printf（“原始项目：\n”）；
打印堆（heap）；
printf（“堆%d\n的项目编号”，堆->大小）；
BuildMinHeap（heap）；
打印堆（heap）；
HT=DeleteMin（堆）；
printf（“删除的结点的值为%d\n“，热处理->重量）；
打印堆（heap）；
HT=哈夫曼（堆）；
打印树（HT）；
返回0；
}

欢迎光临。请提供有关您看到的错误的更多详细信息，以便我们能够更好地帮助您。@RyanWalker

HT=Huffman（heap）在我的C代码的
标签之间。我尝试使用“HT=Huffman（heap）；”来构建一个Huffman树，但是当我运行代码时，“huffmanTree.exe”会显示“停止工作”。我对此非常恼火。你有什么好办法帮我吗？非常感谢。@Ryan Walker谢谢。欢迎。请提供有关您看到的错误的更多详细信息，以便我们能够更好地帮助您。@RyanWalker
HT=Huffman（heap）在我的C代码的
标签之间。我尝试使用“HT=Huffman（heap）；”来构建一个Huffman树，但是当我运行代码时，“huffmanTree.exe”会显示“停止工作”。我对此非常恼火。你有什么好办法帮我吗？非常感谢。@Ryan Walker谢谢你。