Метод Хаффмана

    #include <iostream>
    #include <vector>
    #include <map>
    #include <list>
    #include <fstream>
    using namespace std;
    
    class Node
    {
        public:
        int number; //число
        char symbol; //символ
        Node *left, *right;
    
        Node()
        {
            left=right=NULL;
        }
    
        Node(Node *L, Node *R)
        {
            left =  L;
            right = R;
            number = L->number + R->number;
        }
    };
    
    //перегрузка параметров l, r
    struct MyCompare
    {
        bool operator()(const Node* l, const Node* r) const
        {
            // возвращаем True, если параметр l < r
            return l->number < r->number;
        }
    };
    
    vector<bool> code;
    map<char,vector<bool> > table;
    
    void BuildTable(Node *root)
    {
        if (root->left!=NULL)
        {
            code.push_back(0);
            BuildTable(root->left);
        }
    
        if (root->right!=NULL)
        {
            code.push_back(1);
            BuildTable(root->right);
        }
        //если нашли букву (если буква существует)
        if (root->left==NULL && root->right==NULL)
            table[root->symbol]=code; //ассоциируем эту букву с кодом
    
        code.pop_back();
    }
    
    int main (int argc, char *argv[])
    {
        setlocale(LC_ALL,"Russian");
    
        if(argc != 4)
        {
            cout << "\n         -----------------------------------------------" << endl;
            cout << "        |             Лабораторная работа №2            |" << endl;
            cout << "        |         Сжатие данных: метод Хаффмана         |" << endl;
            cout << "         -----------------------------------------------" << endl;
            cout << " ---------------------------------------------------------------" << endl;
            cout << "| Инструкция:                                                   |" << endl;
            cout << "|                                                               |" << endl;
            cout << "|\t [lab2] +                                               |" << endl;
            cout << "|                                                               |" << endl;
            cout << "|\t [входной_файл.расширение] +                            |" << endl;
            cout << "|\t [кодируемый_файл.расширение] +                         |" << endl;
            cout << "|\t [декодируемый_файл.расширение]                         |" << endl;
            cout << "|                                                               |" << endl;
            cout << " ---------------------------------------------------------------" << endl;
        }
        else
        {
            // считаем частоты символов
            ifstream ifile(argv[1], ios::out | ios::binary);
            map<char,int> m;
            while (1)
            {
                int c = ifile.get();
                if (c == -1)
                    break;
                m[(char)c]++;
            }
    
            //while (!f.eof())
            //{ char c = f.get();
            //   m[c]++;}
    
            // записываем начальные узлы в список list
            list<Node*> t;
            for( map<char,int>::iterator itr=m.begin(); itr!=m.end(); ++itr)
            {
                Node *p = new Node;
                p->symbol = itr->first;
                p->number = itr->second;
                t.push_back(p);
            }
    
            //  создаем дерево
            while (t.size()!=1)
            {
                t.sort(MyCompare());               //сортируем list
                Node *SonL = t.front();            //берем первый элемент и присваем первому элементу который идет в списке
                t.pop_front();                     //удаляем первый элемент, на его место становиться второй
                Node *SonR = t.front();            //который стал дальше первым - становиться правым сыном
                t.pop_front();
    
                Node *parent = new Node(SonL,SonR);
                t.push_back(parent);
            }
    
            Node *root = t.front();   //root - указатель на вершину дерева
            // создаем пары 'символ-код':
            BuildTable(root);
            ifile.clear(); ifile.seekg(0); // перемещаем указатель снова в начало файла
    
            ofstream ofile(argv[2], ios::out | ios::binary);
            int count=0;
            char buf=0;
    
            while (!ifile.eof())
            {
                char c = ifile.get();
                vector<bool> x = table[c];
                for(int n=0; n < x.size(); n++)
                {
                    buf = buf | x[n]<<(7-count);
                    count++;
                    if (count==8)
                    {
                        count=0;
                        ofile << buf;
                        buf=0;
                    }
                }
            }
    
            ifile.close();
            ofile.close();
    
            cout << "Сжатие выполнено..." << endl;
    
            ifstream iifile(argv[2], ios::in | ios::binary);
            ofstream oofile(argv[3]);
    
            Node *p = root;
            count = 0;
            char byte;
            byte = iifile.get();
            while(!iifile.eof())
            {
                bool b = byte & (1 << (7-count) ) ;
                if (b)
                    p=p->right;
                else
                    p=p->left;
                if (p->left==NULL && p->right==NULL)
                {
                    oofile << p->symbol;
                    p = root;
                }
                count++;
                if (count == 8)
                {
                    count = 0;
                    byte = iifile.get();
                }
            }
            iifile.close();
            oofile.close();
            cout << "Файл разархивировано..." << endl;
        }
        return 0;
    }

//comressor
//Код Хаффмана
#include <iostream>
#include <fstream>
#include <map>
#include <vector>
using namespace std;
 
int main()
{
    int weight[0x100];
    for (auto &i: weight)
        i = 0;
    {
        ifstream f("../feinman.html");
        while (!f.eof())
        {
            unsigned char ch;
            f.read((char *)&ch, sizeof(ch));
            ++weight[ch];
        }
    }
    multimap<int /*weight*/, int /* index in the tree */> sortedWeight;
    struct Node
    {
        char ch;
        int parent;
        int zero;
        int one;
        bool branch;
    };
    vector<Node> tree;
    map<char, int> charMap;
    for (size_t i = 0; i < 0x100; ++i)
    {
        if (weight[i] > 0)
        {
            tree.push_back(Node{(char)i, -1, -1, -1, false});
            charMap[i] = tree.size() - 1;
            sortedWeight.insert(make_pair(weight[i], tree.size() - 1));
        }
    }
    while (sortedWeight.size() > 1)
    {
        int w0 = begin(sortedWeight)->first;
        int n0 = begin(sortedWeight)->second;
        sortedWeight.erase(begin(sortedWeight));
        int w1 = begin(sortedWeight)->first;
        int n1 = begin(sortedWeight)->second;
        sortedWeight.erase(begin(sortedWeight));
        tree.push_back(Node{'\0', -1, n0, n1, false});
        tree[n0].parent = tree.size() - 1;
        tree[n0].branch = false;
        tree[n1].parent = tree.size() - 1;
        tree[n1].branch = true;
        sortedWeight.insert(make_pair(w0 + w1, tree.size() - 1));
    }
    vector<bool> data;
    {
        ifstream f("../feinman.html");
        while (!f.eof())
        {
            unsigned char ch;
            f.read((char *)&ch, sizeof(ch));
            auto n = tree[charMap[ch]];
            vector<bool> compressedChar;
            while (n.parent != -1)
            {
                compressedChar.push_back(n.branch);
                n = tree[n.parent];
            }
            data.insert(end(data), compressedChar.rbegin(), compressedChar.rend());
        }
    }
    ofstream f("../lesson48.huff");
    int treeSize = tree.size();
    f.write((char *)&treeSize, sizeof(treeSize));
    for (auto i: tree)
        f.write((char *)&i, sizeof(i));
    for (size_t i = 0; i <= data.size() / 8; ++i)
    {
        unsigned char ch = 0;
        for (int j = 0; j < 8; ++j)
            if (data[i * 8 + j])
                ch |= (1 << j);
        f.write((char *)&ch, sizeof(ch));
    }
}

//decomressor
#include <vector>
#include <fstream>
#include <iostream>
using namespace std;
 
int main()
{
    struct Node
    {
        char ch;
        int parent;
        int zero;
        int one;
        bool branch;
    };
    vector<Node> tree;
 
    ifstream f("../lesson48.huff");
    int treeSize;
    f.read((char *)&treeSize, sizeof(treeSize));
    for (int i = 0; i < treeSize; ++i)
    {
        Node n;
        f.read((char *)&n, sizeof(n));
        tree.push_back(n);
    }
    vector<bool> data;
    while (!f.eof())
    {
        unsigned char ch;
        f.read((char *)&ch, sizeof(ch));
        for (int i = 0; i < 8; ++i)
            data.push_back((ch & (1 << i)) != 0);
    }
    auto n = tree.size() - 1;
    for (auto i: data)
    {
        if (i)
            n = tree[n].one;
        else
            n = tree[n].zero;
        if (tree[n].one == -1)
        {
            cout << tree[n].ch;
            n = tree.size() - 1;
        }
    }
}