Título: Tareas de diseño del sistema de codificación Huffman:
# incluir ltstdlib.h gt
# incluir ltstringgt
# incluir ltrestrictiongt
# incluir ltiostream gt
# incluir ltfstream gt
Usar espacio de nombres std
Nodo Huffman //Un nodo del árbol Huffman
{
int peso;
int parent
int lchild, rchild
char código fuente; // en fuente Almacena un carácter en el conjunto de caracteres, como as "a"
std:: string code; //Almacena el código correspondiente al código fuente del carácter.
};
Árbol Huffman // Clase de árbol Huffman
{
Privado:
HuffmanNode *nodo ; //Nodo[] almacena el árbol de Huffman.
int LeafNum//El número de hojas del árbol de Huffman es también el número de códigos fuente.
Público:
huff mantree();
~ huff mantree();
void CreateHuffmanTree();
void createhuffmantreefromckeyboard();
void CreateHuffmanTreeFromFile();
void encoder();
void decoder();
void print codefile();
void printhufmantree();
void printhufmantree _ aoru(int T, int capa = 1);
} ;
///////////////////////////////////////////// ///////////////////////////////////////////Constructor
//Función: Inicializar árbol de Huffman
//Parámetros de función: Ninguno
//Valor de retorno del parámetro: Ninguno
Huffman Trie::HuffmanTree()
{
Nodo = NULL
número de hoja = 0;
}
////// ////////////////////////////////////////// ///////// //////////////////////////////////Destructor
//Función: Liberar el espacio de la matriz de Huffman.
//Parámetros de función: Ninguno
//Valor de retorno del parámetro: Ninguno
Huffmantree::~Huffmantree()
{
Eliminar [] nodo;
}
//////////////// //////// /////////////////////////////////////////////// //// ////////
//Crear función de árbol de Huffman
//Función: Crear árbol de Huffman (llame al teclado para crear un árbol de Huffman o llame a una función desde un archivo para crear un árbol de Huffman)
//Parámetros de función: Ninguno
//Valor de retorno del parámetro: Ninguno
void HuffmanTree:: CreateHuffmanTree()
{
selección de caracteres;
cout lt lt"¿Quieres leer el árbol de Huffman desde un archivo (presiona 1) o desde el teclado? Ingresa al árbol de Huffman (presiona 2)? ";
CIN gt; gtChoose;
If(Choose=='2') {//Entrada de teclado para crear el árbol Huffman.
createhuffmantreefromckeyboard();
}//choose=='2 '
Else {//Lee la información hfmTree.dat del archivo de árbol de Huffman para construir un árbol de Huffman.
CreateHuffmanTreeFromFile();
}
}
//////////////// /////////////////////////////////////////////////// //// ////////////
//Crea una función de árbol de Huffman desde el teclado.
//Función: Crea un árbol de Huffman desde el teclado.
//Parámetros de función: Ninguno
//Valor de retorno del parámetro: Ninguno
void HuffmanTree::createhuffmantreefromckeyboard(){
int Num
cout lt lt\ nIngrese el número de juegos de caracteres de origen: ";
CIN gt; gtNum
if(Num lt;=1) {
cout lt lt"No se puede construir un árbol de Huffman con menos de dos nodos de hoja. \ n \ n ";
Retorno;
}
LeafNum = Num
nodo = nuevo nodo Huffman[2 * Num- 1];
for(int I = 0; I ltNumI) {//Lea la información del nodo hoja del árbol de Huffman
cout lt lt"Ingrese el primero. "
getchar();
Nodo [i]. código fuente = getchar(); //Los caracteres del texto fuente se almacenan en la matriz de caracteres Info[]
getchar();
cout lt lt"Ingrese el peso o la frecuencia de este carácter";
CIN gt; gt node[i]; Los pesos de los caracteres se almacenan en Node[]weight
Node[i].
Node[i].
Node[i]. -1;
Nodo[i].
Code = " \ 0 ";
}
for(int j = Num; j lt2 * Num-1; J ) {//Bucle para construir los nodos internos de Huffman árbol .
int pos1, pos2
int max1, max2
pos 2 = pos 1 = j
max 2 = max 1 =; numeric _ limits lt; int gt* max();
// Entre los nodos raíz de todos los subárboles, seleccione los dos nodos raíz con el peso más pequeño que finalmente deben apuntar a la parte inferior del nodo raíz. con la marca de menor peso.
//pos2 finalmente debería apuntar al subíndice del nodo raíz con el segundo peso más pequeño.
//max1 almacena el peso del nodo raíz con el peso más pequeño encontrado actualmente.
//max2 almacena el peso del nodo raíz con el segundo peso más pequeño encontrado actualmente.
for(int k = j-1; k gt=0; k - ) {
If(nodo[k]. parent =-1){//si es a El nodo raíz del subárbol,
if (nodo [k]. Peso ltMax1){ //Encuentre un peso mayor que el valor máximo actual.
máx 2 = máximo 1;
máx 1 = nodo[k]. Peso;
pos 2 = pos 1;
pos 1 = k
}
Otros
if(Node[k]. Weight ltMax2){ //Encuentre el segundo peso más grande que sea mayor que el segundo valor más grande actual.
max2 = nodo[k]. Peso;
pos 2 = k;
}
}//if(nodo[j].parent==-1)
} //for
//Construya un nuevo nodo interno del árbol de Huffman en el subíndice I, y sus nodos secundarios izquierdo y derecho son los nodos señalados por pos1 y pos2 arriba.
Nodo[pos1]. parent = j;
Nodo [posición 2]. padre = j;
Nodo[j]. l niño = pos 1;
Nodo[j]. rchild = pos2
Nodo[j]. padre =-1;
Nodo[j]. peso = nodo[pos1]. Nodo de peso[pos2]. Peso;
} //para
//Generar códigos para caracteres en todos los nodos hoja.
for(int m = 0; m ltNumm) {
//Código para generar el nodo [i]. código fuente y guárdelo en Node[i].code.
int j = m;
int j 1;
while(node[j].Parent!=-1) {//Comenzar desde el nodo hoja , al nodo raíz, genere un código de bits, almacenado en código[]
j 1 = nodo[j]. Padre;
if(Nodo[j1].lchild==j)
Nodo[m].code.insert(0, "0");
Otro
Nodo[m].code.insert(0, " 1 "
j = j 1
}
<; p>}cout lt lt "El árbol de Huffman se ha construido con éxito.
\n ";
//Escribe el árbol Huffman creado en el archivo hfmTree.dat
char ch
cout lt lt"Si deseas reemplazar el archivo de árbol original de Huffman (Y/N): ";
CIN gt; gtch;
If (ch!= 'y' amp ampch!='Y') return ;
ofstream fop
fop.open("hfmTree.dat ", IOs::out | IOs::binary | IOs::trunc //Abrir archivo
<); p>if(fop.fail()) {cout lt lt" \nEl archivo del árbol Huffman no se puede abrir y el árbol Huffman no se puede escribir en el archivo hfmTree.dat. \n ";
Retorno;
}
fop . write((char *) amp; Num, sizeof(Num)); // Escribir primero El número de nodos de hoja del árbol de Huffman
for(int n = 0; n lt2 * Num-1; N) {//El último nodo escrito del árbol de Huffman (almacenado en el Nodo [] ).
fop . write((char *) amp; Nodo[n], sizeof(Nodo[n]);
Flush (cout);
}
fop . close(); //Cerrar el archivo
cout lt lt" \nEl árbol Huffman se ha escrito correctamente en el archivo hfmTree.dat.\n " ;
}
//////////////////////////////////// ///////////////////////////////////////////////
//Crear función de árbol Huffman a partir de archivo
//Función: Crear árbol de Huffman a partir de archivo
//Parámetros de función: Ninguno
/. /Valor de retorno del parámetro: Ninguno
void HuffmanTree::CreateHuffmanTreeFromFile(){
ifstream fip
fip.open("hfmTree.dat ", IOs :: binario | IOs::in);
if(fip.fail()) {
cout lt lt"El archivo del árbol Huffman hfmTree.dat no se puede abrir ni crear. Árbol de Huffman. \n ";
Retorno;
}
FIP . read((char *) amp; LeafNum, sizeof(leaf num) );
if(leaf num lt;=1) {
cout lt lt"Los datos en el archivo del árbol de Huffman son incorrectos. El número de nodos de hoja es menor que 2, por lo que No se puede establecer el árbol de Huffman.
\n ";
FIP . close();
Retorno;
}
nodo = nuevo nodo de Huffman[2 * hoja num-1];
for(int I = 0; i lt2 * hoja num-1; i)
FIP read((char *) amp; Node[i] , sizeof(Node[I]);
FIP . close();
cout lt lt"El árbol Huffman se ha creado correctamente a partir del archivo.\n"; p>
}
//////////////////////////////////// //// ///////////////////////////////////////////
// Función de codificación
//Función: Codificación del árbol de Huffman
//Parámetros de función: Ninguno
//Valor de retorno del parámetro: Ninguno
void HuffmanTree::Encoder()
{
Si (Node==NULL) {//No hay ningún árbol de Huffman en la memoria, entonces desde Huffman archivo de árbol Lea información de hfmTree.dat y cree un árbol Huffman
CreateHuffmanTreeFromFile();
if(leaf num lt;=1) {
cout. lt lt"No hay ningún árbol de Huffman en la memoria. La operación fue cancelada.\n\n";
Return;
}
}//Si
char * SourceText//Matriz de cadenas, utilizada para almacenar el texto fuente
//Permite que el usuario elija si desea ingresar el texto fuente desde el teclado o leerlo desde el texto fuente. file ToBeTran.txt.
selección de caracteres;
cout lt lt"¿Quieres leer el texto fuente del archivo (presiona 1) o ingresar el texto fuente desde el teclado ( presione 2)?";
CIN gt; gt select;
if(Choose=='1') {
ifstream FIP 1(" tobe tran . txt ");
if(fip1.fail()) {
cout lt "¡No se puede abrir el archivo fuente! No se puede continuar con la ejecución.\n ";
Retorno;
}
char ch
int k = 0;
mientras(FIP 1 . get(ch) )k ; //Primera lectura Cuando se utiliza un archivo, solo cuenta cuántos caracteres hay en el archivo y almacena el número de caracteres en k.
FIP 1. close();
texto fuente = new char[k 1] //Solicita espacio en la matriz de caracteres para almacenar el texto fuente.
ifstream FIP 2(" tobe tran . txt "); //Lee el archivo fuente por segunda vez y escribe el contenido en SourceText[]
k = 0;
mientras(FIP 2. get(ch))texto fuente[k]= ch;
FIP 2. close();
texto fuente[k]= ' \ 0 ';
}
Else {//Ingrese el texto fuente desde el teclado.
string SourceBuff
CIN . ignore();
cout lt ltIngrese el texto fuente que desea codificar (puede ingresar cualquier longitud, presione Intro para completar). ): \n;
getline(cin, SourceBuff, '\n');
int k = 0;
while(SourceBuff[k]! =' \0')
k;
texto fuente = nuevo char[k 1]
k = 0; while( SourceBuff[k]! ='\0') {
texto fuente[k]= fuente buff[k];
k;
}
texto fuente[k]= '\0';
}
cout lt ltEl texto fuente a codificar es: "";
cout lt ltSourceText lt ltendl
//Iniciar decodificación
ofstream fop("CodeFile.dat", IOs::trunc);//Abrir el código del archivo almacenado
int k = 0;
while(SourceText[k]!='\0') //La cadena de texto fuente se codifica una por una comenzando desde el primer carácter.
{
int I;
for(I = 0; i ltLeafNumI ){ //Encuentra el texto fuente actual que se codificará en el nodo del árbol de Huffman. [] El subíndice del personaje.
If(node[I].source code == source text[k]){//Escribe el código correspondiente en el archivo de código.
fop lt ltnode[i]. Código;
Romper;
};
}
if (i gt=LeafNum) {
cout lt lt"Hay caracteres sin codificar en el texto fuente. La ejecución no puede continuar.\n " lt ltendl
fop close();
Return;
k; //Los caracteres de la cadena de texto fuente se mueven hacia atrás una posición.
}
fop . close();
cout lt ltLa codificación se ha completado y el texto del código se ha escrito en el archivo CodeFile.dat. \n\n";
}
////////////////////////////// / ///////////////////////////////////////////////// ///
//Función de decodificación
//Función: Decodificar el árbol de Huffman
//Parámetros de función: Ninguno
// Parámetros Valor de retorno: Ninguno
void HuffmanTree::Decoder()
{
//Si no hay ningún árbol de Huffman en la memoria, del Huffman. archivo de árbol Lea la información en hfmTree.dat y cree el árbol de Huffman
if(Node==NULL)
{
CreateHuffmanTreeFromFile();
if(leaf num lt;=1) {
cout lt lt "No hay ningún árbol de Huffman en la memoria.
La operación ha sido cancelada. \ n \ n ";
Return;
}
}
//Leer el texto del código del archivo CodeFile.dat CodeStr[]
ifstream FIP 1(" codefile . dat ");
if(fip1.fail()) {
cout lt lt" Ninguno Código , no se puede decodificar. \n ";
Retorno;
}
char * CodeStr
int k = 0;
char ch
mientras(fip1.get(ch)){
k;
}
FIP 1. close();
CodeStr = new char[k 1];
ifstream FIP 2(" codefile . dat "); p>mientras(fip2.get(ch))
CodeStr[k]= ch;
FIP 2. close();
CodeStr[k] = ' \ 0 ';
cout lt lt"El texto fuente decodificado es: ";
of stream fop(" textfile . dat ");
int j = leaf num * 2-1-1; //j apunta a la raíz del árbol de Huffman
int I = 0; //El texto del código comienza desde el primer símbolo y sigue al de Huffman. El árbol comienza desde la raíz y desciende dependiendo del símbolo actual del texto del código
while(CodeStr[i]!='\0') {//Hasta Huo. Árbol Furman, el carácter fuente del nodo hoja correspondiente se traduce
if(CodeStr[i]=='0 ')
j = node[j]. >
Otros
j = node[j].rchild
If(node[j].rchild =-1){//Porque el árbol de Huffman no tiene grado. es un nodo de 1, por lo que esta condición es equivalente a que el nodo [j] sea un nodo hoja
cout lt lt nodo [j] // Muestra los caracteres fuente traducidos en la pantalla. >fop lt lt node[j].
j = leaf num * 2-1-1; //j luego apunta a la raíz del árbol de Huffman
}
i;
}
fop . close();
cout lt lt”\nDecodificado correctamente y guardado en el archivo TextFile.dat. ,\n\n";
}
/////////////////////// ///// /////////////////////////////////////////////////// /////
//Función de código de salida
//Función: genera el código del árbol Huffman del archivo.
//Parámetros de función: Ninguno
//Valor de retorno del parámetro: Ninguno
void HuffmanTree::PrintCodeFile()
{
char ch
int I = 1;
ifstream FIP(" codefile . dat ");
of stream fop(" codeprin . dat ");
if(fip.fail())
{
cout lt lt"No hay ningún archivo de código y el contenido del. el archivo de código no se puede mostrar \ n ";
Return;
}
while(fip.get(ch))
{
cout lt ltch;
fop lt ltch;
if (i==50)
{
cout lt ltendl
fop lt ltendl
I = 0
}
i ;
}
cout lt ltendl
fop lt ltendl
FIP .
fop close(); >
}
/////////////////////////////////////// ///////// ///////////////////////////////////////// Función de salida
//Función: genera el árbol de Huffman directamente desde la memoria o el archivo.
//Parámetros de función: Ninguno
//Valor de retorno del parámetro: Ninguno
void HuffmanTree::printhufmantree()
{
//Si no hay ningún árbol de Huffman en la memoria, lea la información del archivo del árbol de Huffman hfmTree.dat y construya el árbol de Huffman.
if(Nodo==NULL)
{
CreateHuffmanTreeFromFile();
if(hoja num lt;=1) {
cout lt lt "No hay árbol Huffman en la memoria. Operación cancelada.\n \n ";
Regresar;
}
}
ofstream fop("TreePrint.dat", IOs_base::trunc);
fop.close();
printhufmantree_ aoru(2 * número de hoja -1-1);
Regresar;
}
////////////// ////// ///////////////////////////////////////////////// // /////////////
//Función de salida del método cóncavo
//Función: utilice el método cóncavo para generar el árbol de Huffman.
//Parámetros de función: Ninguno
//Valor de retorno del parámetro: Ninguno
void huff mantree::printhufmantree_aoru(int T, int Layer){
//Símbolo cóncavo:
//Subárbol izquierdo
//Raíz
//Subárbol derecho
Si (T!=-1){ //Si es un árbol binario no vacío
// Genera recursivamente el subárbol de la izquierda
printhufmantree _ aoru(Node[T] ). lchild, capa 1); //Directorio raíz de salida
ofstream fop("TreePrint.dat", IOs_base::app);
cout lt ltendl
fop lt ltendl
for(int I = 0; I lt Layer * 5; I) {// Salida de espacios por capa.
cout lt lt" ";
fop lt lt" ";
}
If(nodo[t].l hijo =-1){//Nodo hoja
cout lt lt nodo [T]. Código fuente lt ltnode[T]. peso lt lt"(" lt ltnode[T]. código lt lt")" lt ltendl
fop lt ltnode[T]. Código fuente lt ltnode[T]. Peso lt lt"(" lt lt nodo[T]. Código lt lt")" lt ltendl
}
Else {//Nodo interno
cout lt nodo[T]. peso lt ltendl
fop lt ltnode[T]. Peso lt ltendl
}
fop . close(); // Genera recursivamente el subárbol derecho
printhufmantree _ aoru(Node[T]).
rchild, capa 1);
}
}
int main(){
Huffman Terry Hooft dentro;
selección de caracteres;
mientras(1){
cout lt lt" \ n * * * * * * * * * * * * * * * * * *Bienvenido al sistema de codificación/decodificación Huffman* * * * * * * * * * * * * * * *;
cout lt lt" *Puedes realizar las siguientes operaciones: * \ n ";
cout lt lt"* 1. Construir el árbol de Huffman* \n ";
cout lt lt"* 2. Codificación (el texto fuente ya está en el archivo a traducir, o entrada de teclado)* \n ";
cout lt lt"* 3. Decodificación (el texto del código ya está en el archivo CodeFile)* \n ";
cout lt" lt"* 4. Mostrar código * \ n ";
cout lt lt"* 5. Mostrar árbol de Huffman * \ n ";
cout lt lt"* 6. Salir * \n";
cout lt lt"* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * \n";
cout lt lt" Seleccione una operación: ";
CIN gt;
Cambiar (seleccionar)
{
Caso "1":
CreateHuffmanTree();
Romper
Caso "2":
hooftry.encoder();
Pausa;
Caso "3":
hooftry.decoder();
p>
Pausa;
Caso "4":
Hoftri.print codefile();
Rotura;
Caso "5":
printhufmantree();
Romper;
Caso "6":
cout lt lt" \ n * * * * * * * * * * * * * * *¡Gracias por utilizar este sistema! * * * * * * * * * * * * * * * * * \n \n ";
Sistema("pausa");
Devuelve 0;
}//Cambiar
}//Cuándo
}//principal