Revisión del árbol Huffman y la codificación Huffman (construido a partir de un montón mínimo)

Árbol huffman

El peso de cada nodo se multiplica por el árbol con la suma más pequeña de las longitudes de ruta de los nodos raíz: las
características del árbol binario óptimo Árbol de Huffman:
 No hay ningún nodo con un grado de 1;
 Cualquier arbitrario Los subárboles izquierdo y derecho de los nodos de la hoja siguen siendo árboles Huffman después del intercambio;  Los árboles Huffman con n nodos de hoja tienen un total de 2n-1 nodos;
 Para el mismo conjunto de pesos {w1, w2, ......, wn} , hay diferentes configuraciones del árbol de Huffman
configuración Huffman árbol de
los pesos nodo de punto binario mediante la transformación en un tamaño mínimo de pila, cada uno tomando dos elementos de la pila da nuevos nodos binarios de nuevo en el montón;
cuando se realiza fusión tamaño 1, el resultado final es el árbol Huffman;

1. nodo del árbol

#include <iostream>
#include <string>
using namespace std;
#define MaxNum 64

struct TreeNode{
    int Weight = 0;
    TreeNode *Left = nullptr;
    TreeNode *Right = nullptr;
};

2. estructura del montón

struct HeapNode{// 堆结构
	TreeNode Data[MaxNum];      //data内放着树结构
	int Size =0;        //初始大小为0 
};

3. Función de creación de montón

HeapNode * CreateHeap(){    //建树——返回指向树根节点的指针 
	HeapNode *H = new(HeapNode);
	H->Data[0].Weight = -1;    //哨兵的weight设置为-1
	return H;       //建堆——一次即可 
}

4. Función de eliminación de montón

TreeNode *DeleteMin(HeapNode *H){ //返回堆定的指针 
	int Parent = 0 , Child=0;
	TreeNode temp;
	TreeNode *MinItem = new(TreeNode);       //新建一个minitem
	*MinItem = H->Data[1];   //保存堆顶
	
	temp = H->Data[(H->Size)--];   //拿到堆底的对象，并且size-1
	
	for(Parent=1;Parent *2 <= H->Size; Parent=Child)
	{
		Child= Parent*2;
		//Size就是为了作为边界 
		if(Child!=H->Size && (H->Data[Child].Weight>H->Data[Child+1].Weight))
			Child++;
		if(temp.Weight<=H->Data[Child].Weight)  break;
		else H->Data[Parent]=H->Data[Child];        //下沉 
	}
	//break出来说明找到合适位置 
	 H->Data[Parent] = temp;     //进行赋值
	 return MinItem;       //返回堆定成员指针 
} 

5. Insertar operación de montón

void Insert(HeapNode *H, TreeNode *item){     //将一个树成员插入堆中 
	int i=0;
	i= ++(H->Size);    //i为当前总容量
	//item为指向树成员的指针 
	for (;item ->Weight<H->Data[i/2].Weight;i/=2)  //插入最后，然后上浮 
	//当要插入的成员小于父节点，上浮 
	{
		H->Data[i]=H->Data[i/2];
	 } 
	 H->Data[i] = *item;       //将item所指成员放入堆中 
} 

6. Construya un árbol Huffman
Introduzca un puntero al objeto de montón más pequeño;

TreeNode *Huffman(HeapNode *H){    //把堆变为哈夫曼树 
	TreeNode *T = nullptr;     //初始空指针
	 int num = H->Size;      //一共有num个元素
	 //进行n-1次合并
	 for(int i=0;i<num-1;i++)
	 {
	 	T= new(TreeNode);
	 	T->Left = DeleteMin(H);
	 	T->Right = DeleteMin(H);
	 	T->Weight=T->Left->Weight + T->Right->Weight;
	 	Insert(H,T);    //T为指针——insert(H,T)
		 //要用动态内存创造空间时——用指针 
	  } 
	  T= DeleteMin(H);    
	  return T;      //返回指向堆头的指针 
	  // 
}

Resumen El
árbol Huffman se transforma del montón más pequeño;
puede hacer que el árbol binario sea el árbol binario óptimo;
puede evitar la ambigüedad y construir el árbol binario con el menor costo de codificación;