Diseño en lenguaje C Codificación Huffman
#includelt;stdio.hgt;
#includelt;conio.hgt;
#includelt;iostream.hgt;
# includelt; string.hgt;
#includelt; stdlib.hgt;
#define MAXVALUE 10000 /*Valor de peso máximo*/
#define MAXLEAF 30 / *Número máximo de hojas*/
#define MAXNODE MAXLEAF*2-1 /*Número de nodos*/
#define MAXBIT 50 /*Número máximo de bits de codificación */
typedef struct node /*Definición de tipo de nodo*/
{
char letra;
int peso;
p>int parent;
int lchild;
int rchild;
}HNodeType
typedef struct /*codificación Definición de tipo; */
{
letra de carácter;
int bit[MAXBIT];
int inicio;
}HCodeType;
typedef struct /*tipo de símbolo de entrada*/
{
char s;
int num
}lable;
void HuffmanTree(HNodeType HuffNode[], int n, lable a[])
{
int i, j , m1, m2, x1, x2, temp1;
char temp2
for (i=0; ilt; 2*n-1; i) /*Inicialización de nodo*/
{
HuffNode[i].letter=0
HuffNode[i].weight=0
HuffNode[i; ].parent=-1;
HuffNode[i].lchild=-1
HuffNode[i].rchild=-1; /p>
for (i=0; ilt; n-1; i )
for (j=i 1; jlt; n-1; j ) /*Par de caracteres de entrada Ordenar por peso*/
if (a[j].numgt; a[i].num)
{
temp1=a[ i].num;
a[i].num=a[j].num;
a[j].num=temp1;
temp2=a[i].s;
a[i].s=a[j].s;
a[j].s=temp2;
}
para (i=0;ilt;n;i)
{
HuffNode[i].weight=a[i]. num;
HuffNode[i].letter=a[i].s;
}
for (i=0; ilt; n-1; i) /*Construir árbol de huffman*/
{
m1=m2=MAXVALUE
x1=x2=0; for (j=0; jlt; n i; j)/*Encontrar el nodo con el peso más pequeño y el segundo más pequeño*/
{
if (HuffNode[j].parent= =-1amp;amp;HuffNode[j].weightlt;m1)
{
m2=m1;
x2=x1;
m1=HuffNode[j].weight
x1=j
}
else if (HuffNode[j].parent==-1amp ;amp;HuffNode[j].weightlt;m2)
{
m2=HuffNode[j].weight;
x2=j;
}
}
HuffNode[x1].parent=n i;
HuffNode[x2].parent=n i /*Peso mínimo Combinar; con el siguiente nodo más pequeño*/
HuffNode[n i].weight=HuffNode[x1].weight HuffNode[x2].weight;
HuffNode[n i].lchild =x1;
HuffNode[n i].rchild=x2;
}
}
void HuffmanCode(int n, etiqueta a [])
{
HNodeType HuffNode[MAXNODE];
HCodeType HuffCode[MAXLEAF], cd;
int i, j , c, p;
HuffmanTree(HuffNode, n, a);
for (i=0; ilt; n; i) /* Presione
Codifica la posición del nodo*/
{
cd.start=n-1
c=i
p= HuffNode; [c].parent;
while (p!=-1)
{
if (HuffNode[p].lchild==c)
cd.bit[cd.start]=0;
else cd.bit[cd.start]=1
cd.start--;< / p>
c=p;
p=HuffNode[c].parent
}
for (j=cd.start 1; jlt ; n; j ) /*Código de almacenamiento*/
HuffCode[i].bit[j]=cd.bit[j];
HuffCode[i].start= cd .start;
}
para (i=0; ilt; n; i)
{
HuffCode[i] . letter=HuffNode[i].letter;
printf(" c ",HuffCode[i].letter);
for (j=HuffCode[i].start 1; jlt ; n; j )
printf("d",HuffCode[i].bit[j]);
printf("\n");
}
}
int main()
{
datos de etiqueta[30];
char s[100], *p;
int i, recuento=0
for (;;)
{
coutlt ;lt;" / ¡Encuentre la codificación de Huffman hasta que finalice la entrada! /"lt;lt;endl;
printf("Ingrese algunas letras: ");
scanf("s ", s);
if (!strcmp(s, "end"))
exit(0);
for (i =0;ilt ;30;i )
{
datos[i].s=0;
datos[i].num=0;
}
p=s;
while (*p) /*Calcular el número de caracteres y el número de apariciones
(es decir, peso)*/
{
para (i=0; ilt; =count 1; i)
{
if (datos[i].s==0)
{
datos[i].s=*p;
datos[i].
contar;
romper
}
si (datos[i].s==*p)< / p>
{
datos[i].num
descanso
}
}
p;
}
printf("\n");
printf("letras diferentes: d\n", recuento);< / p>
for (i=0; ilt; count; i)
{
printf(" c ", datos[i].s);
printf("peso: d\n", datos[i].num);
}
HuffmanCode(recuento, datos
); count=0;
}
getch();
}
Este programa está listo, estoy haciendo telegramas. Tienes que calcular la probabilidad de que ocurra tú mismo (se puede decir que es más inteligente). Si no está satisfecho, simplemente haga ligeras modificaciones.