求大佬看看，我这个Huffman数怎么连不起来，输出的时候只有一个根节点

Question

#include<iostream> 
using namespace std;
const int DefaultSize = 10;
using namespace std;
template<class E>
class MinHeap
{
    private:
        E*heap;
        int currentSize;
        int maxHeapSize;
        void siftDown(int start,int m)//采用局部下滑，大的往下滑 ，自上向下 
        {
            int i=start,j=2*i+1;
            E temp=heap[i];
            while(j<m)
            {
                if(j<m&&heap[j]>heap[j+1]) j++;
                if(temp<heap[j]) break;
                else 
                {
                    heap[i]=heap[j];
                    i=j;
                    j=j*2+1;
                }
            }
            heap[i]=temp;
        }
        void siftUp(int start)//大的往下滑，自下向上 
        {
            int i=start,j=(i-1)/2;
            E temp=heap[i];
            while(i>0)
            {
                if(heap[j]<temp) break;
                else
                {
                    heap[i]=heap[j];
                    i=j;
                    j=(j-1)/2; 
                 } 
            }
            heap[i] = temp;
        }
    public:
        MinHeap(int sz=DefaultSize)
        {
            maxHeapSize = (DefaultSize<sz)?sz:DefaultSize;
            heap = new E[maxHeapSize];
            if (heap==NULL)
            {
                cerr<<"存储空间分配失败"<<endl;
                exit(1);
            }
            currentSize=0;
        }
        
        MinHeap(E *arr,int n)
        {
            maxHeapSize=(DefaultSize<n)?n:DefaultSize;
            heap = new E[maxHeapSize];
            if (heap==NULL)
            {
                cerr<<"存储空间分配失败"<<endl;
                exit(1);
            }
            for(int i=0;i<n;i++) heap[i]=arr[i];
            currentSize=n;
            int currentPos=(currentSize-2)/2;
            while(currentPos>=0)
            {
                siftDown(currentPos,currentSize-1);
                currentPos--;
            }
        }
        ~MinHeap()
        {
            delete[]heap;
        }
        
        bool Insert(const E&x)
        {
            if (currentSize==maxHeapSize)
            {
                cerr<<"Heap Full"<<endl;
                return false;
            }
            heap[currentSize]=x;
            siftUp(currentSize);
            currentSize++;
            return true;
        }
        
        bool RemoveMin(E&x)
        {
            if(!currentSize)
            {
                cerr<<"Heap empty"<<endl;
                return false;
            }
            x=heap[0];
            heap[0]=heap[currentSize-1];//补充第一个元素，然后排序
            currentSize--;
            siftDown(0,currentSize-1);
            return true; 
            
            
        }
                
            
};

struct HuffmanNode
{
    float data;
    HuffmanNode*leftChild,*rightChild,*parent;
    HuffmanNode():leftChild(NULL),rightChild(NULL),parent(NULL){}
    HuffmanNode(float elem,HuffmanNode*left=NULL,HuffmanNode*right=NULL,HuffmanNode*pr=NULL):data(elem),leftChild(left),rightChild(right),parent(pr){}
    bool operator <(HuffmanNode&r){
        return data<r.data;
    }    
    bool operator >(HuffmanNode&r){
        return data>r.data;
    }
};

class HuffmanTree
{
    private:
        HuffmanNode*root;
        void merge(HuffmanNode&ht1,HuffmanNode&ht2,HuffmanNode*&parent)
        {
            parent=new HuffmanNode;
            parent->leftChild=&ht1;
            parent->rightChild=&ht2;
            parent->data=ht1.data+ht2.data;
        }
        void Traverse(HuffmanNode*p,ostream&os)
        {
            if(p!=NULL)
            {
                os<<p->data<<endl;
                Traverse(p->leftChild,os);
                Traverse(p->rightChild,os);
            }
        }
        
    void    PreOrder(HuffmanNode *current) {
    if(current != NULL) 
    {
        cout << current->data << " "; // 访问当前结点数据
        PreOrder(current->leftChild); // 递归遍历左子树
        PreOrder(current->rightChild); // 递归遍历右子树
    }
}

    
    
    public:
        void c()
        {
            cout<<root->data<<endl;
            cout<<root->leftChild->data<<endl;
            cout<<root->rightChild->data<<endl;
        }
        HuffmanTree(float w[],int n)
        {
            MinHeap<HuffmanNode> hp;
            HuffmanNode*parent,first,second,work;
            for(int i=0;i<n;i++)
            {
                work.data=w[i];
                work.leftChild=NULL;
                work.rightChild=NULL;
                work.parent=NULL;
                hp.Insert(work);
            }
            
            
            
            for (int j=0;j<n-1;j++)
            {
                hp.RemoveMin(first);
                hp.RemoveMin(second);
                cout<<"first="<<first.data<<endl;
                cout<<"second="<<second.data<<endl;
                merge(first,second,parent);
                hp.Insert(*parent);
            }
            root = parent;
        }
        
        friend ostream& operator <<(ostream& os,HuffmanTree&ht)
        {
            ht.Traverse(ht.root,os);
            return os;
        }
        
    void PreOrder() 
    {
    PreOrder(root);
    }

};

int main()
{
    float a[]={7,5,2,4};
    HuffmanTree p(a,4);

    //p.PreOrder();
    //    cout << p<<endl;
    
}

Answer 1

你好，我是有问必答小助手。为了技术专家团更好地为您解答问题，烦请您补充下（1）问题背景详情，（2）您想解决的具体问题，（3）问题相关代码图片或者报错信息。便于技术专家团更好地理解问题，并给出解决方案。

您可以点击问题下方的【编辑】，进行补充修改问题。