SHARE
TWEET

Untitled

a guest Aug 13th, 2017 43 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. /*
  2.  * To change this template, choose Tools | Templates
  3.  * and open the template in the editor.
  4.  */
  5.  
  6. package Nodos;
  7.  
  8. /**
  9.  *
  10.  * @author ABNER
  11.  */
  12. public class Arbol_Expresion<E>   {
  13.     protected ANodo arbol = new ANodo();
  14.     protected ANodo N_actual= arbol;
  15.     int nodos = 0;
  16.     private String cadenaInOrden = "";
  17.     private String cadenaPreOrden ="";
  18.     private String cadenaPostOrden = "";
  19.  
  20.  
  21.     /**
  22.      * constructor vacío
  23.      */
  24.     public Arbol_Expresion (){
  25.     }
  26.     public ANodo getArbol(){
  27.         return arbol;
  28.     }
  29.     public void setArbol(ANodo arbol){
  30.         this.arbol = arbol;
  31.     }
  32.     public ANodo getN_actual(){
  33.         return N_actual;
  34.     }
  35.     public void setN_actual(ANodo NodoActual){
  36.         this.N_actual=NodoActual;
  37.     }
  38.      public String getCadenaInOrden() {
  39.         return cadenaInOrden;
  40.     }
  41.  
  42.     public String getCadenaPreOrden() {
  43.         return cadenaPreOrden;
  44.     }
  45.     /*
  46.      * Separa la cadena en caracter por caracter e envia el caracter hacia el
  47.      * metodo insertar
  48.      */
  49.     public void enviar_caracter(String cadena){
  50.         int long_cadena = 0;
  51.         int x=0;
  52.         char caracter;
  53.         long_cadena = length(cadena);
  54.         for (x=0;x<=long_cadena; x++){
  55.             caracter = charat(cadena,x);
  56.             insertar(caracter);
  57.         }
  58.  
  59.     }
  60.     /*
  61.      * devuelve la longitud de la cadena
  62.      */
  63.     private int length(String cadena) {
  64.         throw new UnsupportedOperationException("Not yet implemented");
  65.     }
  66.     /*
  67.      * Inserta un nuevo nodo al arbol de expresion
  68.      */
  69.     public ANodo insertar(char signo){
  70.         if(equals(signo,'(')){
  71.             ANodo nuevo = new ANodo();
  72.             nuevo.hder = null;
  73.             nuevo.hizq = null;
  74.             nuevo.padre = null;
  75.             //Si el arbol esta vacio
  76.             if(arbol == null){
  77.                 arbol = nuevo;
  78.                 arbol.padre = null;
  79.                 arbol.hder = null;
  80.                 arbol.hizq = null;
  81.                 arbol.elemento = 0;
  82.                 N_actual = arbol;
  83.                 nodos++;
  84.                 return arbol;
  85.             }
  86.             if(tieneizquierdo(N_actual)){
  87.                 N_actual.hizq = nuevo;
  88.                 nuevo.padre= N_actual;
  89.                 N_actual = nuevo;
  90.                 nodos ++;
  91.                 return arbol;
  92.             }
  93.             else{
  94.                 N_actual.hder = nuevo;
  95.                 nuevo.padre = N_actual;
  96.                 N_actual = nuevo;
  97.                 nodos ++;
  98.                 return arbol;
  99.             }
  100.  
  101.         }
  102.  
  103.  
  104.         if((equals(signo,'+'))||(equals(signo,'-'))||(equals(signo,'*')) || (equals(signo,'/'))){
  105.             N_actual.elemento = signo;
  106.             return arbol;
  107.         }
  108.        
  109.         //si el caracter es parentesis cerrado no hace nada solo retorna
  110.         if (equals(signo,')')){
  111.             return arbol;
  112.         }
  113.         //verifica si el caracter es un digito o una letra
  114.         if (isLetterOrDigit(signo)){
  115.             //si el caracter es una letra
  116.             if(isLetter(signo)) {
  117.                 ANodo nuevo = new ANodo();
  118.                 nuevo.hder = null;
  119.                 nuevo.hizq = null;
  120.                 nuevo.padre = null;
  121.                 //Creo un puntero hacia el nodo actual
  122.                 ANodo auxiliar = N_actual;
  123.                 //si no tiene hijo izquierdo se hacen las devidas apuntaciones
  124.                 if((tieneizquierdo(N_actual))){
  125.                     N_actual.hizq = nuevo;
  126.                     nuevo.padre = N_actual;
  127.                     nuevo.elemento = signo;
  128.                     return arbol;
  129.                 }
  130.                 //Si tiene hijo izquierdo se hacen las devidas apuntaciones en el hijo derecho
  131.                 else{
  132.                     N_actual.hder = nuevo;
  133.                     nuevo.padre = N_actual;
  134.                     nuevo.elemento = signo;
  135.                     //el nodo acual cambia cuando el Hijo derecho ya tiene una pocision;
  136.                     N_actual = auxiliar.padre;
  137.                     return arbol;
  138.                 }
  139.             }
  140.             //Si el caracter es un digito
  141.             if (isDigit(signo)){
  142.                 int numero = 0;
  143.                 //convierto el caracter a entero
  144.                 numero = digit(signo,1);
  145.                 //Creo el nodo
  146.                 ANodo nuevo = new ANodo();
  147.                 nuevo.hder = null;
  148.                 nuevo.hizq = null;
  149.                 nuevo.padre = null;
  150.                 //Creo un puntero hacia el nodo actual
  151.                 ANodo auxiliar = N_actual;
  152.                 //si no tiene hijo izquierdo se hacen las devidas apuntaciones
  153.                 if((tieneizquierdo(N_actual))){
  154.                     N_actual.hizq = nuevo;
  155.                     nuevo.padre = N_actual;
  156.                     nuevo.elemento = signo;
  157.                     return arbol;
  158.                 }
  159.                 //Si tiene hijo izquierdo se hacen las devidas apuntaciones en el hijo derecho
  160.                 else{
  161.                     N_actual.hder = nuevo;
  162.                     nuevo.padre = N_actual;
  163.                     nuevo.elemento = signo;
  164.                     //el nodo acual cambia cuando el Hijo derecho ya tiene una pocision;
  165.                     N_actual = auxiliar.padre;
  166.                     return arbol;
  167.                 }
  168.             }
  169.         }
  170.  
  171.         recorrer();
  172.         return arbol;
  173.  
  174.     }
  175.     //devuelve el caracter de la posicion dada
  176.     private char charat(String cadena, int x) {
  177.         throw new UnsupportedOperationException("Not yet implemented");
  178.     }
  179.  
  180.     private boolean equals(char signo, char c) {
  181.         throw new UnsupportedOperationException("Not yet implemented");
  182.     }
  183.  
  184.     private boolean tieneizquierdo(ANodo N_actual) {
  185.         throw new UnsupportedOperationException("Not yet implemented");
  186.     }
  187.  
  188.     private boolean tienederecho(ANodo N_actual) {
  189.         throw new UnsupportedOperationException("Not yet implemented");
  190.     }
  191.  
  192.     private boolean isDigit(char signo) {
  193.         throw new UnsupportedOperationException("Not yet implemented");
  194.     }
  195.  
  196.     private boolean isLetter(char signo) {
  197.         throw new UnsupportedOperationException("Not yet implemented");
  198.     }
  199.  
  200.     private int digit(char signo, int i) {
  201.         throw new UnsupportedOperationException("Not yet implemented");
  202.     }
  203.  
  204.     private boolean isLetterOrDigit(char signo) {
  205.         throw new UnsupportedOperationException("Not yet implemented");
  206.     }
  207.  
  208.  
  209.  
  210.     /**
  211.      * Cada vez que se hace un cambio en el árbol se invoca a este método
  212.      * para realizar los recorridos en y pre orden y guardarlos en las
  213.      * cadenas respectivas
  214.      */
  215.      private void recorrer(){
  216.         cadenaInOrden = "";
  217.         cadenaPreOrden = "";
  218.         cadenaPostOrden = "";
  219.         inOrden(arbol);
  220.         preOrden(arbol);
  221.  
  222.     }
  223.  
  224.         /**
  225.      * Método privado, auxiliar.
  226.      * Método recursivo para guardar en la variable de instancia cadenaInOrden
  227.      * el orden simétrico de los nodos del árbol
  228.      * @param v nodo a partir del cual se recorrerá el árbol en orden simétrico
  229.      */
  230.     private void inOrden (ANodo v){
  231.         if (!(v.tieneizquierdo()))
  232.             inOrden(v.getHizq());
  233.  
  234.         if (v.esInterno())
  235.             cadenaInOrden+=(v.toString() + "  ");
  236.  
  237.         if(!(v.tienederecho()))
  238.             inOrden(v.getHder());
  239.  
  240.  
  241.     }
  242.     /**
  243.      * Método privado, auxiliar.
  244.      * Método recursivo para guardar en la variable de instancia cadenaInOrden
  245.      * el orden simétrico de los nodos del árbol
  246.      * @param v nodo a partir del cual se recorrerá el árbol en orden simétrico
  247.      */
  248.     private void postOrden (ANodo v){
  249.         if (!(v.tieneizquierdo()))
  250.             postOrden(v.getHizq());
  251.  
  252.         if(!(v.tienederecho()))
  253.             cadenaPostOrden+=(v.toString() + "  ");
  254.             postOrden(v.getHder());
  255.     }
  256.  
  257.     /**
  258.      * Método privado, auxiliar.
  259.      * Método recursivo para guardar en la variable cadenaPreOrden
  260.      * el preorden de los nodos del árbol
  261.      * @param v nodo a partir del cual se recorrerá el árbol en preorden
  262.      */
  263.     private void preOrden (ANodo v){
  264.             cadenaPreOrden+=(v.toString()+" ");
  265.  
  266.            if (!(v.tieneizquierdo())){
  267.                 cadenaPreOrden+=("(");
  268.                 preOrden(v.getHizq());
  269.             }
  270.  
  271.             if(!(v.tienederecho())){
  272.                 preOrden(v.getHder());
  273.                 cadenaPreOrden+=(")");
  274.             }
  275.  
  276.     }
  277.  
  278.     /**
  279.      * Método privado, auxiliar.
  280.      * @param v nodo al que deseamos encontrar el nodo no vacío que le sigue en orden simétrico
  281.      * @return el nodo que sigue a v inorden
  282.      */
  283.     private ANodo getSiguienteInOrden (ANodo v){
  284.  
  285.         if(v.getHizq().esExterno())
  286.             return v;
  287.         else
  288.             return getSiguienteInOrden(v.getHizq());
  289.  
  290.      }
  291.  
  292. }
RAW Paste Data
Top