예제 #1
0
 /// <Lista_Doble>
 /// Este lo agrega en una lista doble
 /// </summary>
 /// <param name="nuevo"></param>
 public void agregar(Caracter nuevo)
 {
     if (Primero == null)
     {
         Primero = nuevo;
         Ultimo  = nuevo;
     }
     else
     {
         agregar(Primero, nuevo);
     }
 }
예제 #2
0
 /// <Recursivo>
 /// Recursivo de agregar lista doble
 /// </summary>
 /// <param name="ultimo"></param>
 /// <param name="nuevo"></param>
 private void agregar(Caracter ultimo, Caracter nuevo)
 {
     if (ultimo.Siguiente == null)
     {
         Ultimo           = nuevo;
         ultimo.Siguiente = nuevo;
         Ultimo.Anterior  = ultimo;
     }
     else
     {
         agregar(ultimo.Siguiente, nuevo);
     }
 }
예제 #3
0
 public void sacarUltimo()
 {
     try
     {
         Ultimo           = Ultimo.Anterior;
         Ultimo.Siguiente = null;
     }
     catch
     {
         Primero = null;
         Ultimo  = null;
     }
 }
예제 #4
0
 /// <Recursivo>
 /// Recursivo de agregar lista doble
 /// </summary>
 /// <param name="ultimo"></param>
 /// <param name="nuevo"></param>
 private void agregarPilaPre(Caracter padre, Caracter nuevo)
 {
     if (padre.Siguiente == null)
     {
         Ultimo          = nuevo;
         padre.Siguiente = nuevo;
         Ultimo.Anterior = padre;
     }
     else
     {
         agregarPilaPre(padre.Siguiente, nuevo);
     }
 }
예제 #5
0
        /// <Principio>
        /// Lee mi cadena que pido al inicio y los separa por los caracteres que lo componen
        /// </summary>
        /// <param name="entrada"></param>
        /// <returns></returns>
        public void leer(string entrada)
        {
            string formula = entrada;

            char[] vector = new char[formula.Length];

            using (StringReader sr = new StringReader(formula))
            {
                sr.Read(vector, 0, formula.Length);

                for (int i = 0; i < formula.Length; i++)
                {
                    Caracter prueba = new Caracter(vector[i].ToString());
                    agregar(prueba);
                }
            }
        }
예제 #6
0
        //*********************************** Calculos por PostOrden//


        public int calculoPostOrden()
        {
            leerAgregar paraPost = new leerAgregar();
            CalculoPre  nuevo    = new CalculoPre();

            paraPost.leer(mostrarPost2);
            Caracter primero = paraPost.Primero;


            for (int i = 0; i < mostrarPost2.Length; i++)
            {
                if (primero.Dato != "*" && primero.Dato != "/" && primero.Dato != "+" && primero.Dato != "-")
                {
                    nuevo.agregarPilaPre(new Caracter(primero.Dato));
                    primero = primero.Siguiente;
                }
                else
                {
                    switch (primero.Dato)
                    {
                    case "*":
                        string derecha = nuevo.verUltimo().Dato;
                        nuevo.sacarUltimo();
                        string izquierda = nuevo.verUltimo().Dato;
                        nuevo.sacarUltimo();

                        int primeroPost = Convert.ToInt16(izquierda), despPrimeroPost = Convert.ToInt16(derecha), multiplicar;
                        multiplicar = primeroPost * despPrimeroPost;

                        string convertido = Convert.ToString(multiplicar);
                        nuevo.agregarPilaPre(new Caracter(convertido));
                        primero = primero.Siguiente;
                        break;

                    case "/":
                        string derecha1 = nuevo.verUltimo().Dato;
                        nuevo.sacarUltimo();
                        string izquierda1 = nuevo.verUltimo().Dato;
                        nuevo.sacarUltimo();

                        int primeroPost1 = Convert.ToInt16(izquierda1), despPrimeroPost1 = Convert.ToInt16(derecha1), dividir;
                        dividir = primeroPost1 / despPrimeroPost1;

                        string convertido1 = Convert.ToString(dividir);
                        nuevo.agregarPilaPre(new Caracter(convertido1));
                        primero = primero.Siguiente;
                        break;

                    case "-":
                        string derecha2 = nuevo.verUltimo().Dato;
                        nuevo.sacarUltimo();
                        string izquierda2 = nuevo.verUltimo().Dato;
                        nuevo.sacarUltimo();

                        int primeroPost2 = Convert.ToInt16(izquierda2), despPrimeroPost2 = Convert.ToInt16(derecha2), restar;
                        restar = primeroPost2 - despPrimeroPost2;

                        string convertido2 = Convert.ToString(restar);
                        nuevo.agregarPilaPre(new Caracter(convertido2));
                        primero = primero.Siguiente;
                        break;

                    case "+":
                        string derecha3 = nuevo.verUltimo().Dato;
                        nuevo.sacarUltimo();
                        string izquierda3 = nuevo.verUltimo().Dato;
                        nuevo.sacarUltimo();

                        int primeroPost3 = Convert.ToInt16(izquierda3), despPrimeroPost3 = Convert.ToInt16(derecha3), sumar;
                        sumar = primeroPost3 + despPrimeroPost3;

                        string convertido3 = Convert.ToString(sumar);
                        nuevo.agregarPilaPre(new Caracter(convertido3));
                        primero = primero.Siguiente;
                        break;
                    }
                }
            }
            int resultado = Convert.ToInt16(nuevo.verUltimo().Dato);

            return(resultado);
        }
예제 #7
0
        //*********************************** Calculos por PreOrden//

        public int calculoPreOrden()
        {
            leerAgregar paraPre = new leerAgregar();
            CalculoPre  nuevo   = new CalculoPre();

            paraPre.leer(mostrarPre2);
            Caracter ultimo = paraPre.Ultimo;

            for (int i = 0; i < mostrarPre2.Length; i++)
            {
                if (ultimo.Dato != "*" && ultimo.Dato != "/" && ultimo.Dato != "+" && ultimo.Dato != "-")
                {
                    nuevo.agregarPilaPre(new Caracter(ultimo.Dato));
                    ultimo = ultimo.Anterior;
                }
                else
                {
                    switch (ultimo.Dato)
                    {
                    case "*":
                        string primero = nuevo.verUltimo().Dato;
                        nuevo.sacarUltimo();
                        string segundo = nuevo.verUltimo().Dato;
                        nuevo.sacarUltimo();

                        int ultimoPre = Convert.ToInt16(primero), anteultimoPre = Convert.ToInt16(segundo), multiplicar;
                        multiplicar = ultimoPre * anteultimoPre;

                        string convertido = Convert.ToString(multiplicar);
                        nuevo.agregarPilaPre(new Caracter(convertido));
                        ultimo = ultimo.Anterior;
                        break;

                    case "/":
                        string primero1 = nuevo.verUltimo().Dato;
                        nuevo.sacarUltimo();
                        string segundo1 = nuevo.verUltimo().Dato;
                        nuevo.sacarUltimo();

                        int ultimoPre1 = Convert.ToInt16(primero1), anteultimoPre1 = Convert.ToInt16(segundo1), dividir;
                        dividir = ultimoPre1 / anteultimoPre1;

                        string convertido1 = Convert.ToString(dividir);
                        nuevo.agregarPilaPre(new Caracter(convertido1));
                        ultimo = ultimo.Anterior;
                        break;

                    case "-":
                        string primero2 = nuevo.verUltimo().Dato;
                        nuevo.sacarUltimo();
                        string segundo2 = nuevo.verUltimo().Dato;
                        nuevo.sacarUltimo();

                        int ultimoPre2 = Convert.ToInt16(primero2), anteultimoPre2 = Convert.ToInt16(segundo2), restar;
                        restar = ultimoPre2 - anteultimoPre2;

                        string convertido2 = Convert.ToString(restar);
                        nuevo.agregarPilaPre(new Caracter(convertido2));
                        ultimo = ultimo.Anterior;
                        break;

                    case "+":
                        string primero3 = nuevo.verUltimo().Dato;
                        nuevo.sacarUltimo();
                        string segundo3 = nuevo.verUltimo().Dato;
                        nuevo.sacarUltimo();

                        int ultimoPre3 = Convert.ToInt16(primero3), anteultimoPre3 = Convert.ToInt16(segundo3), sumar;
                        sumar = ultimoPre3 + anteultimoPre3;

                        string convertido3 = Convert.ToString(sumar);
                        nuevo.agregarPilaPre(new Caracter(convertido3));
                        ultimo = ultimo.Anterior;
                        break;
                    }
                }
            }
            int resultado = Convert.ToInt16(nuevo.verUltimo().Dato);

            return(resultado);
        }
예제 #8
0
 public CalculoPre()
 {
     Primero = null;
     Ultimo  = null;
 }