Scribd
Upload
574 views

Implementacion Del Algoritmo de Huffman en Java

This document describes an implementation of the Huffman coding algorithm in Java. It includes classes for nodes in the Huffman tree, the tree itself, a tree traversal class to generate the encoded bit patterns, and a main Huffman class that handles frequency counting, node arrangement, tree construction and encoding. The program takes a string as input, constructs the Huffman tree, and outputs the bit encoding of each character.

Uploaded by

FrankFerdinandLimachiAimituma
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
574 views

Implementacion Del Algoritmo de Huffman en Java

This document describes an implementation of the Huffman coding algorithm in Java. It includes classes for nodes in the Huffman tree, the tree itself, a tree traversal class to generate the encoded bit patterns, and a main Huffman class that handles frequency counting, node arrangement, tree construction and encoding. The program takes a string as input, constructs the Huffman tree, and outputs the bit encoding of each character.

Uploaded by

FrankFerdinandLimachiAimituma
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
You are on page 1/ 13

IMPLEMENTACION DEL ALGORITMO DE HUFFMAN EN JAVA

Clase nodo:
package huffmanexe;
public class Node
{
public int frequency;
public char c;
public Node left;
public Node right;

public Node(int frequency, char c, Node left, Node right)


{
this.frequency = frequency;
this.c = c;
this.left = left;
this.right = right;
}

public Node()
{
//does Nothing
}

public Node addNode(Node node1, Node node2)


{
if(node1.frequency < node2.frequency)

{
left = node1;
right = node2;
}
else
{
right = node1;
left = node2;
}
frequency = node1.frequency + node2.frequency;
return this;
}
}
Clase tree:
package huffmanexe;
/**
*
* @author franklin aimituma suyo
*/
public class tree extends Node
{
private Node root;

public tree()
{
root = null;
}

public tree(Node node1, Node node2)


{
root = super.addNode(node1, node2);
}

public void insertNode(int freq, char c)


{
root.frequency = freq;
root.c = c;
root.left = null;
root.right = null;
}

public void insertNode(int freq, char c, Node left, Node right)


{
root.frequency = freq;
root.c = c;
this.root.left = left;
this.root.right = right;
}

public void insertNode(Node node)


{

this.root.frequency = node.frequency;
this.root.c = node.c;
this.root.left = node.left;
this.root.right = node.right;
}

public void insertNode(Node node1, Node node2)


{
root = super.addNode(node1, node2);
}
}
Clase transversor:
package huffmanexe;
public class HuffmanTransversor
{
public Node rootNode;
public char c;
public char charArray[];
public int i=0;
public String finalBitPattern = "";
public HuffmanTransversor(Node myNode, char [] charArray)
{
String temp;
int i;
rootNode = myNode;

this.charArray = charArray;
for(i = 0; i < charArray.length; i++)
{
temp = search(rootNode, "", charArray[i]);
finalBitPattern += temp+" ";
System.out.println("Mis valores: "+charArray[i]+" = "+temp);
}
// System.out.println("My bit padre final: "+finalBitPattern);
}

public String search(Node rootNode, String value,char myChar)


{
String valueL ="";
if(rootNode != null)
{
if(rootNode.left != null)
valueL = search(rootNode.left, value+"0", myChar);
if(rootNode.c == myChar)
return value;

else
{
if(valueL == "")

{
return search(rootNode.right, value+"1",myChar);
}
else
{
return valueL;
}
}
}
else
{
return "";
}
}
}
Clase Huffman:
package huffmanexe;
import java.util.*;
/**
* @author franklin aimituma suyo
*/
public class Huffman {
//
private static String value;
private static char charArray[];
//convertidor de string a caracteres
private static int table[] = new int[0x7f];
//mantiene la frecuencia del elemento

private static Node myNode[];


//la principal prioridad de la cola, el rbol final generada se almacena en lugar de 0.
private static int lengthOfTable = 0;
//La verdadera longitud de la tabla que contiene los caracteres.
private static tree myTree;
//Una variable que contiene el rbol
private static int lengthOfNode = 0;
//all increments or decrements are made to this value
public static HuffmanTransversor hC;
//The Class Responsible for Decoding the Huffman Tree

public Huffman(String value)


{
frequencyTable(value);
nodeArrange();
Node x = createTree();
hC = new HuffmanTransversor(x,charArray);
}
public static void frequencyTable(String value)
{
int i;
charArray = value.toCharArray();
for(i = 0; i < charArray.length; i++)
table[getAscii(charArray[i])] += 1;
}

public static int getAscii(char substringValue)


{
return substringValue&0x7f;
}

public static void nodeArrange()


{
int counter = 0;
int j = 0;
for(int i = 0; i < table.length; i++)
{
if(table[i]>0)
counter++;
}

lengthOfTable = counter;
counter = 0;
myNode = new Node[lengthOfTable];

for(int i = 0; i < 127; i++)


{
if(table[i] != 0)
{
myNode[counter]= new Node(table[i], (char)i, null, null);

counter++;
}
}
lengthOfNode = myNode.length;
sort();

public static Node createTree()


{
for(int i = 1; i < lengthOfNode; i++)
{
try
{
if(myNode[1].frequency >= myNode[0].frequency)
{
myTree = new tree(myNode[0],myNode[i]);
myNode[0] = myTree;
moveItems(i, lengthOfNode);
lengthOfNode -= 1;
i -= 1;
sort();
}
else

{
if(i+1 < lengthOfNode)
{
myTree = new tree(myNode[i], myNode[i+1]);
myNode[1] = myTree;
moveItems(i+1, lengthOfNode);
sort();
lengthOfNode -= 1;
i -= 1;
}
else
{
myNode[1] = myNode[1];//revisarlo..........
myNode[0] = new tree(myNode[0], myNode[1]);
}
}
}
catch(Exception e)
{
//I dare this program to crash...hahaha
}
}
return myNode[0];

private static void moveItems(int index, int length)


{ try
{
for(int i = index; i < length; i++)
myNode[i] = myNode[i+1];

}
catch(Exception e)
{
//
}
}
private static void sort()
{
Node temp;
for(int i = lengthOfNode-1; i > 1; i--)
{
for(int j = 0; j < i; j++)
{
if(myNode[j].frequency > myNode[j+1].frequency)
{
temp = myNode[j+1];

myNode[j+1] = myNode[j];
myNode[j] = temp;
}

if(myNode[j].frequency == myNode[j+1].frequency && myNode[j].left != null)


{
temp = myNode[j+1];
myNode[j+1] = myNode[j];
myNode[j] = temp;
}
}
}
}
}
Clase principal:
import java.util.*;
/**
*
* @franklin aimituma suyo
*/
public class HuffmanExe {
/**
* @param args the command line arguments
*/
static Huffman huffman;
private static Scanner input = new Scanner(System.in);
private static String value;

public static void main(String args[])


{
System.out.print("ingrese palabra: ");
value = input.nextLine();
System.out.println("el valor introducido es: "+value);
huffman = new Huffman(value);
System.out.println("La representacin de bits de la cadena que has escrito es:
"+huffman.hC.finalBitPattern);
}
}
Ventana de ejecucin de programa:

You might also like