Red de conocimientos turísticos - Conocimientos sobre calendario chino - 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

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?"stdafx.h"

#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;

}

/***************************************** ** *****************************/

/*?¿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

}

/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;

}