алгоритм Хаффмана

#pragma once
#include<iostream>
using namespace std;
 
struct Node
{
    char ch;
    int prior = 0;
    Node*next;
    Node():ch(0),next(nullptr){}
};
class Stack
{
public:
    Stack():head(nullptr){}
    void Push(char chr,int p=0)
    {
        Node*temp = new Node;
        if (p)
        temp->prior = p;
        temp->ch = chr;
        if (head == nullptr)
        {
            head = temp;
        }
        else
        {
            temp->next = head;
            head = temp;
        }       
    }
    
 
    void Sort()
    {
        Node*a = nullptr;
        Node *b = nullptr;
        Node *c = nullptr;
        Node *e = nullptr;
        Node*tmp = nullptr;
 
        while (e != head->next)
        {
            c = a = head;
            b = a->next;
            while (a != e)
            {
                if (a->prior < b->prior)
                {
                    if (a == head)
                    {
                        tmp = b->next;
                        b->next = a;
                        a->next = tmp;
                        head = b;
                        c = b;
                    }
                    else
                    {
                        tmp = b->next;
                        b->next = a;
                        a->next = tmp;
                        c->next = b;
                        c = b;
                    }
                }
                else
                {
                    c = a;
                    a = a->next;
                }
                b = a->next;
                if (b == e)
                    e = a;
            }
        }
    }
 
 
    
    void Check(Stack&ob)
    {
        int count = 0;
        Node*temp = head;
        
        while (temp)
        {
            Node*temp1 = head;
            while (temp1 != temp)
            {
                if (temp->ch == temp1->ch)
                    ++count;
                temp1 = temp1->next;
            }
            if (count == 0)
            {
                int num = 0;
                Node*t = head;
                while (t)
                {
                    if (t->ch == temp->ch)
                        ++num;
                    t = t->next;
                }
                ob.Push(temp->ch, num);             
            }
            count = 0;
            temp = temp->next;
        }
 
    }
    Node*GetHead() { return head; }
    
    void Print()const
    {
        if (head)
        {
            Node*temp = head;
            while (temp)
            {
                if (temp->prior)
                    cout << temp->prior;
                cout << temp->ch << " ";                
                temp = temp->next;
            }
            cout << "\n\n";
        }
    }
    Stack(const Stack&ob)
    {
        Node*temp = ob.head;
        while (temp)
        {
            Push(temp->ch);
            temp = temp->next;
        }
        cout << "\nCOPIED\n\n";
    }
    Stack(Stack&&ob)
    {
        swap(head, ob.head);
        cout << "\nMOVED";
    }
    void Delete()
    {
        while (head)
        {
            Node*temp = head->next;
            delete head;
            head = temp;
        }
    }
    ~Stack()
    {   
        while (head)
        {       
            Node*temp = head->next;
            delete head;
            head = temp;            
        }
    }
private:
    Node*head;  
};
 
 
 
class Hoffman
{
public:
    Hoffman();
    ~Hoffman();
};