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 representación de bits de la cadena que has escrito es: "+huffman.hC.finalBitPattern); } } Ventana de ejecución de programa:
