最小堆构造哈夫曼树

#include<iostream>
using namespace std;
#define Max 60
    typedef struct TreeNode
        {
            int weight;
            TreeNode *left;
            TreeNode *right;
        }*HuffmanTree,HuffmanNode;


    typedef struct HeapStruct
        {
            HuffmanTree *data;
            int Size;// 当前的节点个数
            int Capacity;// 数组的最大容量
        }*MinHeap,minheap; //最小堆

    void printlist(HuffmanTree L);  //线序遍历哈夫曼树
    void init_HeapStruct(MinHeap &L); //初始化最小堆
    bool empty_MinHeap(MinHeap &L); //判断最小堆是否为空
    HuffmanTree get_newNode(); //返回一个新创建的节点
    void creat_init_MinHeap(MinHeap &L); //创造初始化一个最小堆
    void insert_data(MinHeap &L,HuffmanTree e);//将e 插进这个最小堆
    HuffmanTree delete_data(MinHeap &L); //删除其中最小的权值，也就是堆顶,并返回
    void Readjusting_Node(MinHeap &L,int parent); //调整一个节点
    void Creat_MinHeap(MinHeap &L);// 创造一个最小堆
    HuffmanTree Creat_HuffmanTree(MinHeap &L) ;//用最小堆创造一个哈夫曼树 并返回根节点
    void printlist(HuffmanTree L); //线序遍历哈夫曼树

        int main()
            {
                MinHeap L;
                init_HeapStruct(L);
                creat_init_MinHeap(L);
                cout<<"你想创建几个元素的最小堆"<<endl;
                int num;
                cin>>num;
                for(int i=1;i<=num;i++)
                {
                    L->data[i]->left=NULL;
                    L->data[i]->right=NULL;
                    L->data[i]->weight=i;
                }
               L->Size=num;
               Creat_MinHeap(L); //创建一个最小堆
               HuffmanTree p=Creat_HuffmanTree(L);
               printlist(p);

            }


    void init_HeapStruct(MinHeap &L)  //初始化最小堆 //
        {
            L=NULL;
        }

    bool full_MinHeap(MinHeap &L) //判断最小堆是否是满的
        {
            if(L->Size==L->Capacity)
            {
                return true;
            }
            else
            {
                return false;
            }
        }

    bool empty_MinHeap(MinHeap &L) //判断最小堆是否为空
        {
            if(L->Size==0)
            {
                return true;
            }
            else
            {
                return false;
            }
        }

    HuffmanTree get_newNode() //返回一个新创建的节点
        {
            HuffmanTree L=new HuffmanNode;
            L->left=L->right=NULL;
            L->weight=0;
            return L;
        }


    void creat_init_MinHeap(MinHeap &L) //创造初始化一个最小堆
        {
            if(L==NULL)
                {
                    L=new minheap;
                    L->data=new HuffmanTree[Max+1];
                    for(int i=0;i<=Max;i++)
                    {
                        L->data[i]=new HuffmanNode;

                    }
                    L->data[0]->weight=-1000; //定义一个哨兵元素
                    L->data[0]->left=L->data[0]->right=NULL;
                    L->Capacity=Max;
                    L->Size=0;
                }
            else
                {
                    cout<<"已经分配空间了呦"<<endl;
                }

        }

    void insert_data(MinHeap &L,HuffmanTree e)//将e 插进这个最小堆

       {
           int i=L->Size+1; //i指向要插入的位置
           int temp=e->weight;
           while(L->data[i/2]->weight>temp)
           {
               L->data[i]=L->data[i/2];
               i=i/2;
           }

           L->data[i]=e;
           L->Size++;
       }

   HuffmanTree delete_data(MinHeap &L) //删除其中最小的权值，也就是堆顶,并返回
        {
            if(L==NULL)
                {

                    return NULL;
                }
            else if(empty_MinHeap(L)==true)
                {
                    return NULL;
                }
                else
                 {
                    HuffmanTree Min_data=L->data[1]; //将堆顶元素保存下来
                    HuffmanTree temp=L->data[L->Size]; //将最后一个元素保存下来
                    L->Size--;
                    int parent=1;
                    int Min_Child;
                    while(2*parent<=L->Size) //有左子树时就进行循环
                    {
                        Min_Child=2*parent;

                        if(Min_Child!=L->Size) //如果有右子树
                            {
                                if(L->data[Min_Child+1]->weight<L->data[Min_Child]->weight)
                                    {
                                        Min_Child++;
                                    }
                            }

                         if(temp->weight<L->data[Min_Child]->weight)
                             {
                                    break;
                             }

                        else
                            {
                                                                        L->data[parent]=L->data[Min_Child];
                                parent=Min_Child;
                            }
                    }

                    L->data[parent]=temp;

                    return Min_data;
                }

        }


    void Readjusting_Node(MinHeap &L,int parent) //调整一个节点
        {
            int Min_Child;
            HuffmanTree temp=L->data[parent]; //将要调整的节点先保存起来
            while(2*parent<=L->Size) //如果有左子树
            {
                Min_Child=2*parent;
                if(Min_Child!=L->Size)
                {
                    if(L->data[Min_Child]->weight>L->data[Min_Child+1]->weight)
                    {
                        Min_Child++;
                    }
                }
                   if(L->data[Min_Child]->weight<temp->weight)
                       {
                           L->data[parent]=L->data[Min_Child]; //将最小的这个赋给父节点
                           parent=Min_Child;
                       }
                   else
                       {
                           break;
                       }
            }
                L->data[parent]=temp;

        }

    void Creat_MinHeap(MinHeap &L)
        {
            if(L==NULL||L->Size==0)
                {
                    return ;
                }
            else
                {
                    int i=L->Size/2;
                    while(i>=1)
                    {
                        Readjusting_Node(L,i);
                        i--;
                    }
                }

        }

    HuffmanTree Creat_HuffmanTree(MinHeap &L) //用最小堆创造一个哈夫曼树 并返回根节点
        {
            if(L==NULL)
            {
                return NULL;
            }
            int num=L->Size-1;
            while(num>=1)
            {
                HuffmanTree New_Node=get_newNode();
                New_Node->left=delete_data(L);
                New_Node->right=delete_data(L);
                New_Node->weight=New_Node->left->weight+New_Node->right->weight;
                insert_data(L,New_Node);
                num--;
            }
            HuffmanTree p=delete_data(L);  //`
            return p;
        }

    void printlist(HuffmanTree L) //线序遍历哈夫曼树
        {
            if(L!=NULL)
            {
                cout<<L->weight<<" ";
                printlist(L->left);
                printlist(L->right);
            }
        }