Esempio n. 1
0
        public void EnsambladoDeHuffman(List <ComponentesDeCadaNodo> ListaDeCaracteres)
        {
            while (ListaDeCaracteres.Count > 1)
            {
                var nuevoNodo = new ComponentesDeCadaNodo();
                nuevoNodo = sumaDeProbabilidades(ListaDeCaracteres[0], ListaDeCaracteres[1]);
                ListaDeCaracteres.RemoveAt(0);
                ListaDeCaracteres.RemoveAt(0);//Cero aqui porque al momento de borrar la que estaba antes en 0, la que estaba en 1 pasa a ser la 0



                var nuevaPosicionNodoHuffamn = ListaDeCaracteres.FindIndex(x => x.datosDelCaracter.probabilidad >= nuevoNodo.datosDelCaracter.probabilidad);
                if (nuevaPosicionNodoHuffamn == -1)
                {//Si regresa -1 es porque no hay ninguno mayor que el que se desea incertar, por lo que simplemente se agrega al final
                    ListaDeCaracteres.Add(nuevoNodo);
                }
                else
                {
                    ListaDeCaracteres.Insert(nuevaPosicionNodoHuffamn, nuevoNodo);
                }

                //Tengo que recorrer mi vector hasta encontrar la posicion exacta donde tiene que ir
            }
            raiz = ListaDeCaracteres[0];
            ListaDeCaracteres.Clear();
            ListaDeCaracteres = null;
        }
Esempio n. 2
0
        ComponentesDeCadaNodo sumaDeProbabilidades(ComponentesDeCadaNodo nodo1, ComponentesDeCadaNodo nodo2)
        {
            var padre = new ComponentesDeCadaNodo();
            var informacionNuevoPadre = new ComponentesLecturaInicial();

            padre.datosDelCaracter = informacionNuevoPadre;
            padre.hijoIzquierdo    = nodo1;
            padre.hijoDerecho      = nodo2;
            padre.datosDelCaracter.probabilidad = nodo1.datosDelCaracter.probabilidad + nodo2.datosDelCaracter.probabilidad;
            return(padre);
        }
Esempio n. 3
0
 void asignacionDeCodigoPrefijo(ComponentesDeCadaNodo NodoActual, string codigoPrefijo)
 {
     if (NodoActual.hijoDerecho != null && NodoActual.hijoIzquierdo != null)
     {
         asignacionDeCodigoPrefijo(NodoActual.hijoIzquierdo, codigoPrefijo + "0");
         asignacionDeCodigoPrefijo(NodoActual.hijoDerecho, codigoPrefijo + "1");
     }
     else
     {
         NodoActual.datosDelCaracter.codigoPrefijo = codigoPrefijo;
         diccionarioDePrefijos.Add(NodoActual.datosDelCaracter.codigoPrefijo, NodoActual.datosDelCaracter.caracter);
     }//cout << nNodo->sInformacion.iNumero << "-";
 }
Esempio n. 4
0
        static void Main(string[] args)
        {
            const int buffersLength             = 100;
            var       contador                  = 0;
            var       CantidadTotalDeCaracteres = 0;
            List <ComponentesLecturaInicial> listaDeCaracteres = new List <ComponentesLecturaInicial>();

            using (var stream = new FileStream("PruebaLecturas.txt", FileMode.Open))
            {
                using (var reader = new BinaryReader(stream))
                {
                    CantidadTotalDeCaracteres = Convert.ToInt32(reader.BaseStream.Length);
                    var byteBurffer = new Char[buffersLength];
                    while (reader.BaseStream.Position != reader.BaseStream.Length)
                    {
                        byteBurffer = reader.ReadChars(buffersLength);

                        while (contador < byteBurffer.Length)
                        {
                            ComponentesLecturaInicial caracterParaLista = new ComponentesLecturaInicial();
                            caracterParaLista = listaDeCaracteres.Find(x => x.caracter == byteBurffer[contador]);
                            if (caracterParaLista == null)
                            {
                                caracterParaLista            = new ComponentesLecturaInicial();
                                caracterParaLista.caracter   = byteBurffer[contador];
                                caracterParaLista.frecuencia = 1;
                                listaDeCaracteres.Add(caracterParaLista);
                            }
                            else
                            {
                                caracterParaLista.frecuencia++;
                            }
                            contador++;
                        }
                    }
                }
            }
            //2 opciones para el calculo de las probabilidades....
            //o lo vamos calculando por cada vez que entre a cada condicion del ciclo que tenemos arriba o
            //cuando ya esten todos los datos en la lista recorrer cada posicion de la lista para sacar la probabilidad
            //yo preferiria el 2do la verdad porque se me hace mas optimo
            contador = 0;
            while (contador < listaDeCaracteres.Count)
            {
                listaDeCaracteres[contador].probabilidad = Convert.ToDouble(listaDeCaracteres[contador].frecuencia) / Convert.ToDouble(CantidadTotalDeCaracteres);
                contador++;
            }
            //una vez leido y con las probabilidades ya se comienza el Huffman :v
            listaDeCaracteres.Sort((comp1, comp2) => comp1.probabilidad.CompareTo(comp2.probabilidad));
            var nodosParaHuffman = new List <ComponentesDeCadaNodo>();

            contador = 0;
            while (contador < listaDeCaracteres.Count)
            {
                var nodoTransicion = new ComponentesDeCadaNodo();
                nodoTransicion.datosDelCaracter = listaDeCaracteres[contador];
                nodosParaHuffman.Add(nodoTransicion);
                contador++;
            }
            listaDeCaracteres = null;
            var algoritmoDeHuffman = new Huffman();

            algoritmoDeHuffman.EnsambladoDeHuffman(nodosParaHuffman);
            algoritmoDeHuffman.Prefijos();
            contador = 0;
        }