Cree un árbol de Huffman y codifique los pesos de la siguiente manera w={5, 29, 7 8, 14, 13, 3, 11}Escriba código c
#include?"hfm.h"
#includelt;string.hgt;
#includelt;malloc.hgt ;?
#includelt;stdio.hgt;
#includelt;stdlib.hgt;
#includelt;ctype.hgt;
#includelt;limits.hgt;
#includelt;iostreamgt;
#define?
#define?
#define? ¿OK?1
#define?ERROR?1
#define? define?INFEASIBLE?-1
typedef?int?Status;
typedef?int?Boolean;
/************************************ ** *************** *************************/
/*?La mejor abreviatura del árbol binario: ¿árbol de Huffman? */
/****************************************** ***********************************/
//Estructura de árbol de Huffman
;?typedef?struct{
unsigned?int?weight;?//weight
unsigned?int?parent,?lchild,?rchild;?/ / Ambos lados del nodo principal del árbol y dos nodos secundarios izquierdo y derecho
}HTNode,?*HuffmanTree;
typedef?char**?HuffmanCode;
//Devuelve el número ordinal del nodo raíz del árbol con el peso más pequeño entre los i nodos para la llamada select()
int?Min(HuffmanTree?T,?int?i){
int?j,? bandera;
unsigned?int?k?=?UINT_MAX;?//d--gt;UINT_MAX?=?//d--gt;UINT_MAX?=?
T [flag].parent?=?1; //el padre de la bandera es 1 para evitar la búsqueda secundaria
return?flag; //return
}
void?Select(HuffmanTree?T,?int?i,intamp;?s1,?intamp;?s2){
//Seleccione los números de nodo raíz de los dos nodos con el peso más pequeño de i nodos, s1 es el que tiene el número de serie más pequeño
int?j;
s1?=?Min(T, i);
s2?=?Min( T, i);
if(s1?gt;?s2){
<p>j?=?s1;
s1?=?s2;
s2?=?j;
}
}
//Valor binario de decodificación de árbol representado por HuffmanCode
void?HuffmanCoding(HuffmanTree ?amp; HT, ?HuffmanCodeamp; HC, ?int*?w, ?int?n) {
/w almacena los pesos de n caracteres (todos 0), construye el árbol de Huffman HT y encuentra el código de Huffman HC de n caracteres
int?m ,?i,? s1,?s2,?start;
void?HuffmanCoding(HuffmanTreeamp;HT,amp;HuffmanCodeamp;HC),
void?HuffmanCoding(HuffmanTreeamp;HT, amp;HuffmanCodeamp;HC ),
void? p>
unsigned?c,?f;
char*?cd;
/ Asignar espacio de almacenamiento
HuffmanTree?p;
if?(n?lt;=1)
Retorno;
/ Hay 2n-1 nodos de árbol para n caracteres (nodos de hoja), por lo que el nodo de árbol m
m?=?2?*?n??1;
HT?= (HuffmanTree)malloc(? (m? ?1)*sizeof(HTNode));?//El elemento 0 no se utiliza
//Este paso inicializa los nodos hoja del árbol de Huffman
for(p ?=?HT??1,?i?=?1;?i?lt;=?n;?i,?p,w)
{
(*p ).peso?=?*w;
(*p).lchild?=?0;
(*p).rchild?=?0; p>(*p).parent?=?0;
}
//Este paso es para inicializar los nodos que no son hoja del árbol de Huffman
para?(;??i?lt;=?m;?i,?p){
(*p).parent?=?0;
} p>
/***************************************** ** *****************************/
/*?¿Después de completar los preparativos? Empieza a construir el árbol de Huffman
/************************************ * ***********************************/
para(i?=? n ?1;?i?lt;=?m;?i )
{
/Seleccione HT[1~i-1] con parent=0 y peso mínimo Nodos con números de serie s1 y s2
Select(HT,?i?-?1,?s1,?s2);?//referencia de paso
HT[s1] .parent?= ?HT[s2].parent=?i;
HT[i].lchild?=?s1;
HT[i].rchild?=?s2 ;
HT[i].peso?=?HT[s1].peso ?HT[s2].peso;
}
<p>/************************************************ *************************/
/*?Invertir el hash de cada nodo hoja desde el nodo hoja hasta la raíz ¿Codificación del nodo Furman? */
/****************************************** ************************************/
// Asigne un encabezado que contenga n códigos de caracteres Vector de puntero, ([0] no utilizado)
HC?=?(HuffmanCode)malloc((n? ?1)*sizeof(char*));?
cd? =?(char*)malloc(n*sizeof(char)); //asignar espacio de trabajo para encontrar el código
cd[n?-?1] =?\0';? // Símbolo de terminación
for(i?=?1;?i?lt;=?n;?i)?// Atraviesa cada nodo
{
inicio?=?n?-?1;
para?(c?=?i,?f?=?HT[i].parent;?f?! =?0;?c ?= ?f,f?=?HT[f].parent){? //Recorrido de cada nodo hasta la raíz
// Codificación en orden inverso desde el nodo hoja hasta la raíz
si ?(HT[f].lchild?=?c)
cd[--start]? =?';
else
cd[ --start]? =?' 1';
}
HC[i] =?(char*)malloc((n?-?start)*tamañode (char ));?//Generar un bloque de memoria para almacenar caracteres
//Asignar espacio para el código de carácter i-ésimo
strcpy(HC[i],? amp; cd[start ]);?//asignar cadena de cd a cd
}
free(cd);?//recursos gratuitos
} p>
/declaración de función
int?Min(HuffmanTree?T,?int?i);?//Encuentra el número de secuencia más pequeño del peso más pequeño entre los i nodos y regresa
void?Select(HuffmanTree?T,?int?i,?intamp;?s1,?intamp;?s2);?//Seleccione el más pequeño (izquierda) de los dos pesos mínimos para s1 y el derecho para s2
void?HuffmanCoding(HuffmanTree?amp; HT, ?HuffmanCodeamp; HC, ?int*?w, ?int?n); //Codificación y decodificación de Huffman
int? main(){
Árbol Huffman?HT;
Código Huffman?HC;
int
?*w, ?n, ?i;
printf("Ingrese el número de peso (gt; 1):
scanf_s("d", amp; n ) ;
w?=?(int*)malloc(n*sizeof(int));
printf("Ingrese d pesos (forma) en orden:\n" , n);
para?(i??=?0;?i?lt;=?n?1;i )
{
scanf_s ( "d", w i);
}
HuffmanCoding(HT,?HC,?w,?n);
para?0; p >
}