Java - Ayuda Trabajo final Algoritme de huffman!!!

package huffman;

import java.io.BufferedReader;

import java.io.FileNotFoundException;

import java.io.FileReader;

import java.io.FileWriter;

import java.io.IOException;

import java.util.ArrayList;

import java.util.PriorityQueue;

import java.util.Scanner;

import java.util.Comparator;

import java.util.List;

class Nodo {

// Declaración de var.

    int frecuencia;

    char caracter;

// Declar. de hijos.

    Nodo izq;

    Nodo der;

}

// Comparación para la cola de prioridades.

class MyComparator implements Comparator<Nodo> {

    // Compara las frecuencias.

    public int compare(Nodo x, Nodo y)

    {

        return x.frecuencia - y.frecuencia;

    }

}

public class Huffman {

    public static String toPrint(Nodo raiz, String s, String print) {

        // Verifica si tiene hijos y si posee un char.

        if (raiz.izq

                == null

                && raiz.der

                == null

                && Character.isLetter(raiz.caracter)) {

            // Suma el print actual con el anterior y lo retorna.

            print += raiz.caracter + ":" + s + "\n";

            return print;

        }

        // Va recursivamente por los hijos del arbol.

        print = toPrint(raiz.izq, s + "0", print);

        print = toPrint(raiz.der, s + "1", print);

        return print;

    }

    public static int contarLetras(String cadena, char caracter) {

        int posicion;

        int contador = 0;

        // Ubica la posición del char.

        posicion = cadena.indexOf(caracter);

        // Cuenta las veces que posee el char.

        while (posicion != -1) {

            contador++;

            posicion = cadena.indexOf(caracter, posicion + 1);

        }

        return contador;

    }

    public static int[] obtenerFrecuencias(String palabra, char[] letras) {

        int[] frecuencias = new int[letras.length];

        // Crea un array de la frecuencias a partir de la función contarLetras.

        for (int i = 0; i < letras.length; i++) {

            frecuencias[i] = contarLetras(palabra, letras[i]);

        }

        return frecuencias;

    }

    public static char[] obtenerLetrasUnicas(char[] letras) {

        String palabra = "";

        // Toma el char [] y retorna un char[] con letras no repetidas.

        for (int i = 0; i < letras.length; i++) {

            // Realiza un array de letras que no se repiten.

            if (!palabra.contains(letras[i] + "")) {

                palabra += letras[i];

            }

        }

        return palabra.toCharArray();

    }

    // Lee el archivo de texto y entrega una lista.

    public static List readData(String file) throws FileNotFoundException, IOException {

        List<String> matrix = new ArrayList<String>();

        String line = null;

        FileReader f = new FileReader(file);

        BufferedReader b = new BufferedReader(f);

        while ((line = b.readLine()) != null) {

            matrix.add(line);

        }

        return matrix;

    }

    public static void main(String[] args) throws IOException {

        // Instancias

        Scanner s = new Scanner(System.in);

        List o = readData(".\\entrada.in");

        // Convierte la lectura en un String.

        String u = (String) o.get(0);

        // Convierte el String en un char [] con minúsculas.

        char[] charArrayP = u.toLowerCase().toCharArray();

        // Convierte el String de caracteres a uno sin caracteres repetidos.

        char[] caracteres = obtenerLetrasUnicas(charArrayP);

        // OBtiene la longitud del caracter.

        int n = caracteres.length;

        // Obtiene un int [] de frecuencias.

        int[] frecuencias = obtenerFrecuencias(u, caracteres);

        // Se instancia la cola de prioridad.

        PriorityQueue<Nodo> cola = new PriorityQueue<Nodo>(n, new MyComparator());

        for (int i = 0; i < n; i++) {

            Nodo nodo = new Nodo();

            // Se crea los nodos con cada caracter y frecuencia asociado.

            nodo.caracter = caracteres[i];

            nodo.frecuencia = frecuencias[i];

            nodo.izq = null;

            nodo.der = null;

            // Se agregan a la cola de prioridad.

            cola.add(nodo);

        }

        Nodo raiz = null;

        // Se va colocando nodos conectados hasta que la cola de prioridad se termine.

        while (cola.size() > 1) {

            Nodo x = cola.peek();

            cola.poll();

            Nodo y = cola.peek();

            cola.poll();

            Nodo f = new Nodo();

            // Crea el nodo union con la suma de la frecuencias.

            f.frecuencia = x.frecuencia + y.frecuencia;

            f.caracter = '-';

            f.izq = x;

            f.der = y;

            raiz = f;

            cola.add(f);

        }

        // Se obtiene la impresión de nodos.

        String write = toPrint(raiz, "", "");

        // Se obtiene el codigo traducido.

        String traducido = toTraduce(write, charArrayP);

        // Se imprime el código, más el diccionario a la salida.

        toWrite(".\\salida.out", write + traducido);

    }

    public static String toTraduce(String codigo, char[] palabras) {

        // Separa las lineas del diccionario.

        String palabra = "";

        String[] lineas = codigo.split("\n");

        String[] dic = null;

        for (char a : palabras) {

            for (String b : lineas) {

                // Separa el diccionario en letra y código.

                dic = b.split(":");

                if (a == dic[0].charAt(0)) {

                    // Se agrega el valor del código si la letra es igual al del diccionario.

                    palabra += String.valueOf(dic[1]);

                }

            }

        }

        return palabra;

    }

    // Se escribe el archivo de salida con el STRING.

    public static void toWrite(String archivo, String impresion) throws IOException {

        FileWriter output = new FileWriter(archivo);

        output.write(impresion);

        output.close();

    }

}

// C++ program to encode and decode a string using 

// Huffman Coding. 

#include <bits/stdc++.h>

#define MAX_TREE_HT 256

using namespace std;

// to map each character its huffman value 

map<char, string> codes;

// to store the frequency of character of the input data 

map<char, int> freq;

// A Huffman tree node 

struct MinHeapNode

{

    char data;             // One of the input characters 

    int freq;             // Frequency of the character 

    MinHeapNode *left, *right; // Left and right child 

    MinHeapNode(char data, int freq)

    {

        left = right = NULL;

        this->data = data;

        this->freq = freq;

    }

};

// utility function for the priority queue 

struct compare

{

    bool operator()(MinHeapNode* l, MinHeapNode* r)

    {

        return (l->freq > r->freq);

    }

};

// utility function to print characters along with 

// there huffman value 

void printCodes(struct MinHeapNode* root, string str)

{

    if (!root)

        return;

    if (root->data != '$')

        cout << root->data << ": " << str << "\n";

    printCodes(root->left, str + "0");

    printCodes(root->right, str + "1");

}

// utility function to store characters along with 

// there huffman value in a hash table, here we 

// have C++ STL map 

void storeCodes(struct MinHeapNode* root, string str)

{

    if (root==NULL)

        return;

    if (root->data != '$')

        codes[root->data]=str;

    storeCodes(root->left, str + "0");

    storeCodes(root->right, str + "1");

}

// STL priority queue to store heap tree, with respect 

// to their heap root node value 

priority_queue<MinHeapNode*, vector<MinHeapNode*>, compare> minHeap;

// function to build the Huffman tree and store it 

// in minHeap 

void HuffmanCodes(int size)

{

    struct MinHeapNode *left, *right, *top;

    for (map<char, int>::iterator v=freq.begin(); v!=freq.end(); v++)

        minHeap.push(new MinHeapNode(v->first, v->second));

    while (minHeap.size() != 1)

    {

        left = minHeap.top();

        minHeap.pop();

        right = minHeap.top();

        minHeap.pop();

        top = new MinHeapNode('$', left->freq + right->freq);

        top->left = left;

        top->right = right;

        minHeap.push(top);

    }

    storeCodes(minHeap.top(), "");

}

// utility function to store map each character with its 

// frequency in input string 

void calcFreq(string str, int n)

{

    for (int i=0; i<str.size(); i++)

        freq[str[i]]++;

}

// function iterates through the encoded string s 

// if s[i]=='1' then move to node->right 

// if s[i]=='0' then move to node->left 

// if leaf node append the node->data to our output string 

string decode_file(struct MinHeapNode* root, string s)

{

    string ans = "";

    struct MinHeapNode* curr = root;

    for (int i=0;i<s.size();i++)

    {

        if (s[i] == '0')

           curr = curr->left;

        else

           curr = curr->right;

        // reached leaf node 

        if (curr->left==NULL and curr->right==NULL)

        {

            ans += curr->data;

            curr = root;

        }

    }

    // cout<<ans<<endl; 

    return ans+'\0';

}

// Driver program to test above functions 

int main()

{

    string str = "geeksforgeeks";

    string encodedString, decodedString;

    calcFreq(str, str.length());

    HuffmanCodes(str.length());

    cout << "Character With there Frequencies:\n";

    for (auto v=codes.begin(); v!=codes.end(); v++)

        cout << v->first <<' ' << v->second << endl;

    for (auto i: str)

        encodedString+=codes[i];

    cout << "\nEncoded Huffman data:\n" << encodedString << endl;

    decodedString = decode_file(minHeap.top(), encodedString);

    cout << "\nDecoded Huffman Data:\n" << decodedString << endl;

    return 0;

}

Caracter	Frecuencia	Código

L		1		10110

o		5		00101

r		4		00100

e		6		01000

m		3		00001

[Espacio]	10		01010

i		7		01001

p		2		11011

s		5		00110

u		2		11100

d		3		00010

l		2		11101

t		5		00111

a		2		11110

,		1		10111

c		3		00011

n		2		11111

g		1		11000

.		2		00000

M		1		11001

b		1		11010

public static void main(String[] args) {

    String s = loadArchivo();

//        String s = "LAPTOP";

    Map<Character, Simbolo> map = getMapaCaracteresFrecuencias(s);

    Simbolo[] simbolos = getSimbolosOrdenados(map);

//        System.out.println("\nSimbolods ordenados: ");

//        for (int i = 0; i < simbolos.length; i++) {

//            System.out.println(i + ": " + simbolos[i].getCaracter() + ": " + simbolos[i].getFrecuencia());

//        }

    //Creamos una lista de nodos, un nodo por cada simbolo

    List<Nodo> nodos = getListaNodos(simbolos);

    //Procesamos la lista de nodos para transformarla en un arbol binario

    Nodo arbol = getArbol(nodos);

    //recorremos el arbol para setear la codificación en base a la ruta

    recorrerArbol(arbol, map);

    Map<String, Character> diccionario = getDiccionario(map);

    System.out.println("\nCaracter\tFrecuencia\tCódigo");

    map.forEach((k, v) -> {

        System.out.println((k.equals(' ') ? "[Espacio]\t" : k + "\t\t") + v.getFrecuencia() + "\t\t" + v.getCodificacion());

    });

    String codigoHuffman = "";

    for (int i = 0; i < s.length(); i++) {

        codigoHuffman += map.get(s.charAt(i)).getCodificacion();

    }

    System.out.println("frase: " + s);

    System.out.println("Código Huffman: " + codigoHuffman);

    System.out.println("Decodificado: " + decodificar(codigoHuffman, diccionario));

}