Pruebas Sonarqube Juan Alvarez, Nicolas Gonzalez, Daniela Martin

[danniela18]

import java.util.ArrayList ; import java.util.Comparator ; importar java.util.HashMap ;

público de clase HEncoder {

public  HashMap < Character , String > encoder =  new  HashMap <> (); // para codificar
public  HashMap < String , Character > decoder =  new  HashMap <> (); // para decodificar

 nodo de clase privada estática  { 

    Personaje ch;
    Frecuencia entera
    Nodo a la izquierda;
    Nodo correcto;

     Nodecomparator final estático  público Ctor = new Nodecomparator ();   

    public  static  class  Nodecomparator  implementa  Comparator < Node > {

        @Anular
        public  int  compare ( Nodo  o1 , Nodo  o2 ) {
            devuelve o2 . freq - o1 . freq;
        }

    }
}

 HEncoder público ( alimentador de cadenas  ) {
    // 1. mapa de freq
    HashMap < Character , Integer > freqmap =  new  HashMap <> ();
    for ( int i =  0 ; i < feeder . length (); ++ i) {
        char ch = alimentador . charAt (i);
        if (freqmap . containsKey (ch)) {
            freqmap . put (ch, freqmap . get (ch) +  1 );
        } else {
            freqmap . put (ch, 1 );
        }
    }

    // 2. preparar el montón del conjunto de claves
    genericheap < Node > heap =  new genericheap < Node > ( Node . Ctor );
    ArrayList < Character > k =  new  ArrayList <> (freqmap . KeySet ());
    para ( Carácter c : k) {
        Nodo n =  nuevo  nodo ();
        n . ch = c;
        n . left =  null ;
        n . derecho =  nulo ;
        n . freq = freqmap . obtener (c);
        montón . agregar (n);
    }

    // 3.Preparar árbol, eliminar dos, fusionar, volver a agregarlo
    Nodo fn =  nuevo  nodo ();
    mientras que (montón . size () ! =  1 ) {
        Nodo n1 = montón . removeHP ();
        Nodo n2 = montón . removeHP ();
        fn =  nuevo  nodo ();

        fn . freq = n1 . freq + n2 . freq;
        fn . left = n1;
        fn . derecha = n2;

        montón . agregar (fn);
    }

    // 4. transversal

    poligonal (montón . removeHP (), " " );
}

 recorrido vacío  privado ( Nodo nodo , String osf ) {  

    if (node . left ==  null  && node . right ==  null ) {
        codificador . poner (nodo . ch, OSF);
        decodificador . put (osf, nodo . ch);
        regreso ;
    }
    atravesar (nodo . izquierda, OSF +  " 0 " );
    atravesar (nodo . derecho, OSF +  " 1 " );

}

// trabajo de compresión hecho aquí
public  String  compress ( String  str ) {
    String rv =  " " ;
    for ( int i =  0 ; i < str . length (); ++ i) {
        rv + = codificador . get (str . charAt (i));
    }
    devolver rv;
}

// para descomprimir
 Descompresión de cadena  pública ( String str ) { 
    String s =  " " ;
    Código de cadena =  " " ;
    for ( int i =  0 ; i < str . length (); ++ i) {
        código + = str . charAt (i);
        if (decodificador . containsKey (código)) {
            s + = decodificador . obtener (código);
            code =  " " ;
        }
    }

    devolver s;
}

}