Разбор программы "Архиватор"

#include <iostream>
#include <math.h>
using namespace std;
 
/*==================================================================
                Обьявление структур,массивов и переменных
==================================================================*/
 
struct  symbol{         //структура для символа
char    value;          //значение символа
float   prob;           //вероятность символа
char    code[256];      //префиксный код
symbol  *left;          //указатель на левый узел
symbol  *right;};       //указатель на правый узел
 
int     size_fr[256]={0};//частота встречаемости
int     count=0;        //сумма частот встречаемости
bool    flag;           //флаг выхода из цикла проверки на ошибку ввода
symbol  temp;           //временная-для промежуточного хранения результата
symbol  temp2;
int     sz_alphabet=1;
/*==================================================================
                Обьявление процедур и функций
==================================================================*/
 
symbol  *Tree(symbol*[],int);       //рекурсивная ф-ция создания дерева Хаффмана
float   L_sz(symbol [],int);            //среднее кол-во бит L на один код Хаффмана
float   H_sz(symbol [],int);            //среднее кол-во бит L на один код Хаффмана
void    Rand_str(char*,symbol*,char*,int ,symbol*[]);
void    Pref_code(symbol*);         //процедура получения кода узла
void    Encode(char*,char*,symbol*);//процедура кодирования
void    Decode(char*,char*,symbol*);//процедура декодирования
 
/*==================================================================
                Главная функция-точка входа в программу
==================================================================*/
 
int main(int argc,char* argv[])
{
//Отображение русского языка в консоле
setlocale(LC_ALL,"Russian"); 
 
//Задание и инициализация переменных
char *alphabet  = new char[256];    //массив для записи алфавита
short number_of_symbols=0;          //число символов в алфавите
char *bin_code  = new char[1000];   //массив для отображения бинарного закодированного кода
bin_code[0]=0;                      //для обозначения конца строки при первом присоединение к строке
char *encode_txt= new char[1000];   //текст для кодирования
char *decode_txt= new char[1000];   //восстановленный текст
 
float H;
float L;
symbol symbols[256]={0};            //инициализируем массив записей
symbol *addr_symbol[256];           //инициализируем массив указателей на записи
 
/*==================================================================
                Ввод алфавита и проверка на ошибки ввода
==================================================================*/
 
    do {
    flag=true;
    cout<<"Введите алфавит из 8-10 символов :   ";
    cin>>alphabet;
        if(strlen(alphabet)>7)
        {
            if(strlen(alphabet)<11)
            {
                sz_alphabet=strlen(alphabet);
                for (int i=0;i!=sz_alphabet;i++)
                {
                    for (int n=0;n!=sz_alphabet;n++)
                    {
                        if(alphabet[i]==alphabet[n])
                        {
                            if (i!=n)
                            {
                                cout <<"При задании алфавита встречены повторные символы!"<<endl;
                                cin.clear();           // Сбрасываем флаг ошибки
                                cin.ignore(255, '\n'); // Очищаем буфер
                                flag=false;
                            }
                        }
                        else flag=true;
                    if(!flag)break;
                    }
                if(!flag)break;
                }
            }
            else 
            {cout <<"Введенный алфавит состоит больше чем из 10 символов!"<<endl;
            flag=false;}
        }
        else 
        {cout <<"Введенный алфавит состоит меньше чем из 8 символов!"<<endl;
        flag=false;}
    }while (!flag);
    cout <<"Алфавит :    "<<alphabet<<endl;
 
/*==================================================================
                    Задаем таблицу частот символов
==================================================================*/
 
    for ( int i = 0; i < sz_alphabet; i++)
    {
        cout <<"Задайте частоту встречаемости для символа "<<alphabet[i]<<" :  ";
        cin>>size_fr[i];
        symbols[i].value=alphabet[i];
        count+=size_fr[i];
        if (!cin.good())
        {
            cin.clear();           // Сбрасываем флаг ошибки
            cin.ignore(255, '\n'); // Очищаем буфер
            cout<<"Введенный параметр не верен!"<<endl;
            i--;
        }
    }
    cout<<"Сумма частот встречаемости символов :    "<<count<<endl;
 
    Rand_str(alphabet,symbols,alphabet,sz_alphabet,addr_symbol);
 
    //вызов функции создания дерева Хаффмана   
    symbol * temp = Tree(addr_symbol,sz_alphabet);
    //вызов функции получения кода
    Pref_code(temp);
    //вызов функции расчета среднего количество бит L на один код Хаффмана
    L=L_sz(symbols,sz_alphabet);
    cout << "среднеe количество бит L на один код Хаффмана  : " <<L<< endl;
    //вызов функции расчета теоретического минимума бит на один код 
    H=H_sz(symbols,sz_alphabet);
    cout << "теоретический минимум бит на один код  : " <<H<< endl;
    if(L>=H)
    {
        cout << "Теоретические расчеты подтверждены : L >= H!!! " <<endl;
        cout << "Введите строку в соответствии с алфавитом и частотй символов : " <<endl;
        cin>>encode_txt;
    //функция кодирования строки
    Encode(encode_txt,bin_code,symbols);
    cout << "Закодированная строка : " << endl;
    cout << bin_code << endl;
    //функция декодирования строки
    Decode(bin_code,decode_txt, temp);
    cout << "Раскодированная строка : " << endl;
    cout << decode_txt << endl;
    }
    else 
    {
        cout << "L < H Ошибка вычисления!!! " <<endl;system("pause");
        return 0;
    }
 
    cout << "Введите произвольно строку битовой последовательности :   " <<endl;
    cin>>bin_code;
    Decode(bin_code,decode_txt, temp);
    cout << "Раскодированная строка : " << endl;
    cout << decode_txt << endl;
    delete alphabet;
    delete bin_code;
    delete decode_txt;
        system("pause");
        return 0;
        
}
 
/*==================================================================
                    Вспомогательные алгоритмы
==================================================================*/
 
//рекурсивная функция кодирования дерева
symbol *Tree(symbol *addr_symbol[],int number) 
{ 
    symbol *temp;
    temp = new symbol;
    temp->prob = addr_symbol[number-1]->prob+addr_symbol[number-2]->prob;
    temp->code[0] = 0;
    temp->left = addr_symbol[number-1];
    temp->right = addr_symbol[number-2];
    if ( number == 2 )
        return temp;
    else {
    //внесение в нужное место массива элемента дерева Хаффмана
      for (int i = 0; i < number; i++)
        if ( temp->prob > addr_symbol[i]->prob ) 
        {
          for(int j = number - 1; j > i; j--)
          { addr_symbol[j] = addr_symbol[j-1]; }
            
            addr_symbol[i] = temp;
            break;
        } 
    }
  return Tree(addr_symbol,number-1);
}
 
//ф-ия расчета среднего кол-ва бит L на один код Хаффмана
float L_sz(symbol symbols[],int number)
{
    float L=0;
    float *l=new float [number];
    for(int i=0;i<number;i++)
    {
        l[i]=0;
        for(int j=0;symbols[i].code[j]!=0;j++)
        {
        l[i]++;
        }
        l[i]*=symbols[i].prob;
    }
    for(int i=0;i<number;i++)
    {
        L+=l[i];
    }
    return L;
}
//ф-ия расчета теоретического минимума бит на один код 
float H_sz(symbol symbols[],int number)
{
    float H=0;
    float *l=new float [number];
    for(int i=0;i<number;i++)
    {
        l[i]=log(symbols[i].prob)/log(2.0);
        l[i]=-(l[i]*symbols[i].prob);
    }
    for(int i=0;i<number;i++)
    {
        H+=l[i];
    }
    return H;
}
//функция нахождения префиксного кода для узла
void Pref_code(symbol *temp) 
{ 
  if ( temp->left ) {
    strcpy(temp->left->code,temp->code);
    strcat(temp->left->code,"0");
    Pref_code(temp->left);
  }
  if ( temp->right ) {
    strcpy(temp->right->code,temp->code);
    strcat(temp->right->code,"1");
    Pref_code(temp->right);
  }
}
//функция кодирования строки
void Encode(char *encode_txt,char *bin_code,symbol *symbols)
{
    int tmp_symbol;
    for (int  i = 0; i < strlen(encode_txt); i++)
    {
        tmp_symbol = encode_txt[i];
        for (int  j = 0; j < strlen(encode_txt); j++)
        {
            if ( tmp_symbol == symbols[j].value )
            {
                strcat(bin_code,symbols[j].code);
            }
        }
    }
}
//функция декодирования строки
void Decode(char *bin_code,char *decode_txt,symbol *temp)
{
  symbol *present;// указатель в дереве
  char pr_bit;// значение текущего бита кода
  int number_of_bit;
  int pr_symbol;// индекс распаковываемого символа
  bool flag;  // флаг конца битовой последовательности
  flag = false;
  pr_symbol = 0;
  number_of_bit = 0;
  present = temp;
  //пока не закончилась битовая последовательность
  while ( number_of_bit != strlen(bin_code) ) {
    //пока не пришли в лист дерева
    while (present->left != NULL && present->right != NULL && 
           number_of_bit != strlen(bin_code) ) {
      //читаем значение очередного бита
      pr_bit = bin_code[number_of_bit++];
      //бит – 0, то идем налево, бит – 1, то направо
      if ( pr_bit == '0' ) 
        present = present->left;
      else 
        present = present->right;
    }
    //пришли в лист и формируем очередной символ
    decode_txt[pr_symbol++] = present->value;
    present = temp;
  }
  decode_txt[pr_symbol] = 0;
}
 
 
 
 
void Rand_str(char *encode_txt,symbol *symbols,char *alphabet,int number_of_symbols,symbol *addr_symbol[])
{
 
/*==================================================================
                    Расчет вероятностей символов
==================================================================*/
 
    for ( int i = 0; i < number_of_symbols; i++)
    {
        symbols[i].prob = (float)size_fr[i] / count;
        cout<<"Вероятность встречаемости символа "<<alphabet[i]<<" : "<<symbols[i].prob<<endl;
    }
 
/*==================================================================
                В массив указателей заносим адреса записей
==================================================================*/
 
    for ( int i = 0; i < number_of_symbols; i++) 
    addr_symbol[i] = &symbols[i];
 
/*==================================================================
                    Сортировка по убыванию 
==================================================================*/
symbol temp;
    for ( int i = 1; i < number_of_symbols; i++)
    {
        for ( int j = 0; j < number_of_symbols - 1; j++)
        {
            if ( symbols[j].prob < symbols[j+1].prob )
            {
            temp = symbols[j];
            symbols[j] = symbols[j+1];
            symbols[j+1] = temp;
            }
        }
    }
}