Estoy buscando urgentemente orientación de un experto en lenguaje C o C++. . . Es necesario construir un árbol de Huffman. Por favor ayúdenme con el código de programación real. .

¡Muchas gracias! ! !

#include

#define maxsize 10000 /*La longitud máxima de la cadena compilada en la función de codificación*/

#define max 10000 /*Número máximo de caracteres*/

typedef struct /*Definir un nodo huffnode*/

{

char data /*Campo de datos* /

int peso,parent,izquierda,derecha;

}huffnode;

typedef struct /*Definir un nodo huffnode*/

{

char cd[max]; /*array cd almacena el código Huffman*/

int start

}huffcode

huffcode; hcd[max];

huffnode ht[2*max];

huffnode a[2*max]

void hfmtree ( huffnode ht[] ) /*Crear un árbol de Huffman*/

{

int i,k,x1,x2,n,m1,m2; ].peso;

para ( i=1; i<=2*n-1; i++ )

ht[i].parent = ht[i].left = ht [i].right = 0; /*Inicialización*/

for ( i=n+1; i<=2*n-1; i++ )

{

m1 = m2 = 200000000;

x1 = x2 = 0;

para ( k=1; k<=i-1 ; k++ ) /*k es el subíndice del nodo que se puede comparar*/

if ( ht[k].parent == 0 ) /*Cuando el nodo padre del nodo actual no existe* /

if ( ht[k].weight < m1 ) /*El peso del nodo actual es menor que el peso mínimo*/

{

m2 = m1; >

x2 = x1;

m1 = ht[k].peso

x1 = k

}

; else if ( ht[k].weight < m2 ) /*El peso del nodo actual es mayor que el peso mínimo pero menor que el segundo peso mínimo*/

{

>

m2 = ht[k].peso

x2 = k

}

ht[x1].padre = ht[x2] .parent = i;

ht[i].peso = ht[x1].peso + ht[x2].peso

ht[i].left = x1; /p>

ht[i].right = x2;

}

}

salida nula ( huffnode ht[] ) /*salida ha Codificación Huffman*/

{

huffcode d

int i,n,c,f,k,x

n; = ht[0].peso;

for ( i=1; i<=n; i++ )

{

d.start = n+ 1; /*d.start es el elemento de la pila*/

c = i; /*c almacena el nodo actual*/

f = ht[i].parent;/* f almacena el nodo padre del nodo actual*/

while ( f != 0 )

{

if ( ht[f].left == c ) /*Si el nodo actual está a la izquierda de su nodo padre*/

d.cd[--d.start] = '0'

else

p>

d.cd[--d.start] = '1'; /*Cuando el nodo actual está a la derecha de su nodo padre*/

c = f ; /*El nodo actual El nodo padre del punto está asignado a c*/

f = ht[f].parent /*El nodo padre de c está asignado a f*/

}

hcd[i] = d; /*Asigna el código Huffman del nodo actual a la matriz hcd[i]*/

}

printf ( "Código Huffman: \n"

for ( i=1; i<=n; i++ ) /*Generar el código Huffman de cada nodo*/

{

if ( ht[i].data == ' ' )

printf ( "' ' "

else

x = hcd[i].start; ; k++ ) /*Pasar codificación de Huffman de salida de pila*/

p>

printf( "%c",hcd[i].cd[k]

printf( "\n"

}

printf ( "* * * * * * * * * * * * * * * * * * * \n\n"

}

codificación nula); (huffcode hcd[],huffnode ht[]) /*Función de codificación, dada una cadena, genera su código Huffman correspondiente*/

{

int i, j,n,m ,k,x;

char in[maxsize],out[2*maxsize];/*in almacena la cadena a compilar y out almacena el código compilado*/

m = 0;

printf ( "Ingrese una cadena:"

getchar()

gets(in

para ( i=0; i

{

para ( j=1; j <=ht[0].weight; j++ ) /*ht[0].weight almacena el número de nodos ponderados*/

if ( in[i ] == ht[j].data ) / *Si el carácter de entrada es el mismo que un nodo ponderado*/

{

x = hcd[j].start

for ( k =x; k<=ht[0].peso; k++ )

salida[m++] = hcd[j].cd[k]

}

}

printf ( "El resultado de la codificación es:\n"

for ( i=0; i

printf ( "%c",out[i] );

printf ( "\n"

}

decodificación nula (huffcode hcd[]); huffnode ht[])/*Función de decodificación, ingresa un flujo de código y genera sus caracteres correspondientes*/

{

int i,j, n,k,x,m,w ;

char in[maxsize*2],out[maxsize];/*La matriz in almacena el flujo de código y la matriz out almacena la matriz correspondiente*/

printf ( "Ingrese una cadena que consta de 0 y 1:\n"

scanf ( "%s",in

n = strlen(in

i = m = 0; /*i es el subíndice de la matriz de entrada, m es el subíndice de la matriz de salida*/

while ( i

{

para ( j=1; j<=ht[

0].weight; j++ )/*ht[0].weight es el número de nodos ponderados*/

{

x = hcd[j].start < /p; >

for ( k=x,w=i; k<=ht[0].weight; k++,w++) /*k es el subíndice de hcd[j].cd[]*/

if ( in[w] != hcd[j].cd[k] )

break

if ( k > ht[0].peso )

{

salida[m++] = ht[j].data;

descanso

}

}

i = w;

}

printf ( "El resultado de la decodificación es:\n" ); ; i

printf ( "%c",out[i]

printf ( "\n" ); p>

}

int main()

{

int select,index,i,k,len

; char str[10000];

printf ( "Ingrese un artículo para codificar:\n"

get (str); =0; index<=200; index++){//Inicialización

a[index].data = '#'; p>

}

len = strlen(str);

k = 27;

para ( índice=0; índice

if ( str[index]>='A' && str[index]<='Z' ){

a[str[index]- 'A '+1].data = cadena[índice];

a[cadena[índice]-'A'+1].peso++

}

else{

a[k].data = str[index];

a[k].weight++; > }

}