¡Se necesita con urgencia un sujeto experimental de la estructura de datos del sistema de codificación y decodificación Huffman! ! ! ! !
#include lt;stdlib.hgt;
#include lt;string.hgt;
#define N 100
#define M 2*N-1
typedef char * HuffmanCode[2*M]; //código huffman
typedef struct
{
int peso; //peso
int parent; //nodo padre
int LChild; //nodo hijo izquierdo
> int RChild; //nodo secundario derecho
}HTNode, Huffman[M 1]; //árbol huffman
typedef struct Node
{
int peso; //peso del nodo hoja
char c; //nodo hoja
int num; //longitud del código binario del nodo hoja
}WNode, WeightNode[N];
/*** Generar caracteres y pesos de nodos hoja***/
void CreateWeight( char ch[], int *s, WeightNode CW, int *p)
{
int i, j, k
int etiqueta
* p=0; //El número de nodos hoja
//Cuenta el número de apariciones de caracteres y colócalos en CW
for(i=0; ch[i]! =' \0'; i )
{
etiqueta=1
para(j=0; jlt; i; j )
if(ch[j]==ch[i])
{
etiqueta=0
descanso
if(tag)
{
CW[ *p].c=ch[i]
CW[; *p ].peso=1;
for(k=i 1;ch[k]! = '\0';k )
if(ch[i]== ch[ k])
CW[*p].weight; //los pesos se acumulan
}
}
*s= i; // longitud de la cadena
}
/******* crear HuffmanTree*******/
void CreateHuffmanTree (Huffman ht, WeightNode w, int n)
{
int i, j
int s1, s2
/ /inicializar el árbol de Huffman
for(i=1;ilt;=n;i)
{
ht[i].we
derecho = w[i].peso;
ht[i].parent=0;
ht[i].LChild=0
ht[; i].RChild =0;
}
for(i=n 1; ilt; =2*n-1; i )
{ p>
ht[i].weight=0;
ht[i].parent=0
ht[i].LChild=0; p>
ht[i]..RChild=0;
}
for(i=n 1; ilt; = 2*n-1; i )
{
for(j=1;jlt;=i-1;j)
if(!ht[j].parent)
break;
s1=j; //encuentra el primer nodo con padres distintos de cero
for(;jlt;=i-1;j)
if( !ht [j].parent)
s1=ht[s1].weightgt; ht[j].weight?j：s1;
ht[s1] .parent=i; ;
ht[i].LChild=s1;
for(j=1;jlt;=i-1;j)
if(!ht [j ].parent)
break;
s2=j; //encuentra el segundo nodo que tiene un padre distinto de cero
for(;jlt;= i- 1; j )
if(!ht[j].parent)
s2=ht[s2].weightgt;ht[j].weight?j:s2;
p>ht[s2].parent=i;
ht[i].RChild=s2;
ht[i].peso=ht[ s1].weight ht[s2].weight; //Acumulación de peso
}
}
/*********** Codificación de nodos de hoja *************/
void CrtHuffmanNodeCode(Huffman ht, char ch[], HuffmanCode h, WeightNode Weight, int m, int n)
{
int i, c, p, inicio;
char *cd
cd=(char *)malloc(n*; sizeof(char));
cd[n-1]='\0'; //establece 0 al final
for(i=1;ilt;=n; i)
{
start=n-1; //la cadena del cd comienza al final cada vez
c=i; p> p=ht[ i].parent; //p en n 1 a 2n-1
while(p) //recorre el padre hasta 0
{
> start--; //avanzar en orden
if(ht[p]. luego establecer en 0
cd[start]='0';
De lo contrario // De lo contrario, establecido en 1
cd[start]='1';
c=p
p=ht[p]. parent;
}
peso[i].num=n- start; //La longitud del código binario (incluido el 0 al final)
h[i ]=(char *)malloc((n-start)*sizeof(char));
strcpy(h[i],&cd[start]); a la matriz de punteros h
}
free(cd); // Liberar memoria del cd
system("pause");
}
/********* Codificación de todos los caracteres************/
void CrtHuffmanCode(char ch[], HuffmanCode h, HuffmanCode hc, peso del nodo de peso, int n, int m)
{
int i, k
for(i=0; ilt; m; i )
{
for(k=1;klt.=n;k) /* Encuentra el valor ch[i]*/
del peso[k ].c (ch[i]==peso[k].c)
break;
hc[i]=(char *)malloc((peso[k]. num)* sizeof( char));
strcpy(hc[i], h[k]); //Copiar código binario
}
}
/***** Decode*****/
void TrsHuffmanTree(Huffman ht, WeightNode w, HuffmanCode hc, int n, int m)
{
int i=0, j, p;
printf("***StringInformation***\n"); ilt; m )
{
p= 2*n-1; //recorrer hacia abajo desde el nodo padre al nodo hoja
for(j=0; hc[i][j]! = '\0'; j )
{
si (hc[i][j]=='0')
p=ht[p ].LChild;
else
p=ht[p].RChild;
}
printf("c",w [p].c ); /*Imprimir información original*
i;
}
}
/**** * Memoria FreeHuffmanCode *****/
void FreeHuffmanCode(HuffmanCode h, HuffmanCode hc, int n, int m)
{
> int i;
for(i=1;ilt;=n;i)// libera el código del nodo hoja
free(h[i]); p>
for(i=0;ilt;m;i) //Libera el código de todos los nodos
free(hc[i]);
void main()
{
int i, n=0 /*n es el número de nodos hoja*/
char ch[N]; /*ch[N] guarda la cadena de entrada*/
Huffman ht ; /* Bifurcación de Huffman */
HuffmanCode h, hc; /*h representa el código del nodo hoja, hc representa el código de todos los nodos*/
WeightNode peso; /* representa la información del nodo hoja*/
printf("\t***HuffmanCoding***\n");
printf("ingrese la información: ");
gets(ch); /* cadena de entrada */
CreateWeight(ch, amp; m, peso, amp; n); /* create Weight(ch, amp; m, peso, amp; n); /* crear Peso(ch, amp; m, peso, amp; n) peso, amp /* Generar información del nodo hoja, m es la longitud de la cadena ch; []*/
printf("***Información de peso***\n Nodo "
for(i=1;ilt;=n;i) /* Salida los caracteres y pesos de los nodos de hoja*/
printf("c ", peso[i].c
printf("\nPeso "); p> for(i=1; ilt ; = n; i )
printf("d ", peso[i].peso
CreateHuffmanTree(ht, peso, n); ); /* Generar árbol de Huffman */
printf("\n***HuffamnTreeInformation***\n"); tLChild\tRChild\n") ;
for(i=1;ilt;=2*n-1;i) /*Imprimir información del árbol de Huffman*/
printf(" /td\td\ td\td\n", i, ht[i].weight, ht[i].Parent, ht[i].LChild, ht[i].RChild);
CrtHuffmanNodeCode(ht, ch, h, peso, m, n); /*El código del nodo hoja*/
printf(" ***NodeCode***\n"); código del nodo hoja*/
for(i=1;ilt;=n;i)
{
printf
("\tc:", peso[i].c);
printf("s\n", h[i]); > CrtHuffmanCode(ch, h, hc, peso, n, m); /* Códigos de todos los caracteres*/
printf("***StringCode***\n"); Código de cadena*/
for(i=0;ilt;m;i)
printf("s",hc[i]);
sistema ("pausa");
TrsHuffmanTree(ht, peso, hc, n, m) /*Decode**/
FreeHuffmanCode(h, hc, n, m);
sistema("pausa");
}