Árboles Las listas enlazadas, pilas y colas son estructuras de datos lineales (es decir, secuencias). Un árbol es una estructura de datos bidimensional no lineal, con propiedades especiales. Los nodos de un árbol contienen dos o más enlaces. En esta sustentación hablaremos sobre los árboles binarios cuyos nodos contienen dos enlaces (uno de los cuales puede ser null). El nodo raíz es el primer nodo en un árbol. Cada enlace en el nodo raíz hace referencia a un hijo. El hijo izquierdo es el primer nodo en el subárbol izquierdo (también conocido como el nodo raíz del subárbol izquierdo), y el hijo derecho es el primer nodo en el subárbol derecho (también conocido como el nodo raíz del subárbol derecho). Los hijos de un nodo específico se llaman hermanos. Un nodo sin hijos se llama nodo hoja. Generalmente, los científicos computacionales dibujan árboles desde el nodo raíz hacia abajo; exactamente lo opuesto a la manera en que crecen los árboles naturales. En nuestro ejemplo de árbol binario crearemos un árbol binario especial, conocido como árbol de búsqueda binaria. Un árbol de búsqueda binaria (sin valores de nodo duplicados) cuenta con la característica de que los valores en cualquier subárbol izquierdo son menores que el valor del nodo padre de ese subárbol, y los valores en cualquier subárbol derecho son mayores que el valor del nodo padre de ese subárbol. La forma del árbol de búsqueda binaria que corresponde a un conjunto de datos puede variar, dependiendo del orden en el que se inserten los valores en el árbol. La aplicación crea un árbol de búsqueda binaria compuesto por valores enteros, y lo recorre (es decir, avanza a través de todos sus nodos) de tres maneras: usando los recorridos inorden, preorden y postorden recursivos. El programa genera 10 números aleatorios e inserta a cada uno de ellos en el árbol. Analicemos el programa del árbol binario. El método main de la clase PruebaArbol, empieza creando una instancia de un objeto Árbol vacío y asigna su referencia a la variable árbol Arbol arbol = new Arbol(); En las líneas for ( int i = 1; i <= 10; i++ ) valor = numeroaleatorio.nextint( 100 ); System.out.print( valor + " " ); arbol.insertarnodo( valor ); } // fin de for se generan 10 enteros al azar, cada uno de los cuales se inserta en el árbol binario mediante una llamada al método insertarnodo.después el programa realiza recorridos preorden, inorden, postorden y demás metodos El método insertarnodo de la clase Arbol public void insertarnodo( int valorinsertar ) if ( raiz == null ) raiz = new NodoArbol( valorinsertar ); // crea el nodo raíz aquí else raiz.insertar( valorinsertar ); // llama al método insertar } // fin del método insertarnodo Determina primero si el árbol está vacío. De ser así, en la línea raiz = new NodoArbol( valorinsertar ); se asigna un nuevo objeto NodoArbol, se inicializa el nodo con el entero que se insertará en el árbol y se asigna el nuevo nodo a la referencia raíz. Si el árbol no está vacío, en la línea raiz.insertar( valorinsertar ); se hace una llamada al método insertar de NodoArbol. public void insertar( int valorinsertar ) // inserta en el subárbol izquierdo if ( valorinsertar < datos ) if ( nodoizq == null ) nodoizq = new NodoArbol( valorinsertar ); else // continúa recorriendo el subárbol izquierdo nodoizq.insertar( valorinsertar ); } // fin de if else if ( valorinsertar > datos ) // inserta en el subárbol derecho if ( nododer == null ) nododer = new NodoArbol( valorinsertar ); else // continúa recorriendo el subárbol derecho nododer.insertar( valorinsertar ); } // fin de else if } // fin del método insertar } // fin de la clase NodoArbol
Este método utiliza la recursividad para determinar la posición del nuevo nodo en el árbol e inserta el nodo en esa posición. En un árbol de búsqueda binaria, un nodo puede insertarse solamente como nodo hoja. El método insertar de NodoArbol compara el valor a insertar con el valor de datos en el nodo raíz. Si el valor a insertar es menor que los datos del nodo raíz, el programa determina si el subárbol izquierdo está vacío. De ser así, se asigna un nuevo objeto NodoArbol, se inicializa con el entero que se insertará y se asigna el nuevo nodo a la referencia nodoizquierdo. En caso contrario, se hace una llamada recursiva a insertar para que se inserte el valor en el subárbol izquierdo. Si el valor a insertar es mayor que los datos del nodo raíz, el programa determina si el subárbol derecho está vacío. De ser así, se asigna un nuevo objeto NodoArbol, se inicializa con el entero que se insertará y se asigna el nuevo nodo a la referencia nododerecho. En caso contrario, se hace una llamada recursiva a insertar para que se inserte el valor en el subárbol derecho. Si el valorinsertar ya se encuentra en el árbol, simplemente se ignora. Los métodos recorridoinorden, recorridopreorden y recorridopostorden llaman a los métodos ayudantes de Árbol llamados ayudanteinorden, ayudantepreorden y ayudantepostorden, respectivamente, para recorrer el árbol e imprimir los valores de los nodos. Los métodos ayudantes en la clase Arbol permiten iniciar un recorrido sin tener que pasar el nodo raíz al método. La referencia raíz es un detalle de implementación que no debe ser accesible para el programador. Los métodos recorridoinorden, recorridopreorden y recorridopostorden simplemente toman la referencia privada raiz y la pasan al método ayudante apropiado para iniciar un recorrido del árbol. El caso base para cada método ayudante determina si la referencia que recibe es null y, de ser así, regresa inmediatamente. El método ayudanteinorden define los pasos para un recorrido inorden: 1. Recorrer el subárbol izquierdo con una llamada a ayudanteinorden 2. Procesar el valor en el nodo. 3. Recorrer el subárbol derecho con una llamada a ayudanteinorden. El recorrido inorden no procesa el valor en un nodo sino hasta que se procesan los valores en el subárbol izquierdo de ese nodo. El recorrido inorden de un árbol de búsqueda binaria imprime los valores de los nodos en orden ascendente. El proceso de crear un árbol de búsqueda binaria ordena los datos de antemano; por lo tanto, a este proceso se le conoce como ordenamiento de árbol binario. El método ayudantepreorden define los pasos para un recorrido preorden: 1. Procesar el valor en el nodo 2. Recorrer el subárbol izquierdo con una llamada a ayudantepreorden 3. Recorrer el subárbol derecho con una llamada a ayudantepreorden El recorrido preorden procesa el valor en cada uno de los nodos, a medida que se van visitando. Después de procesar el valor en un nodo dado, el recorrido preorden procesa los valores en el subárbol izquierdo y después los valores en el subárbol derecho. El método ayudantepostorden define los pasos para un recorrido postorden: 1. Recorrer el subárbol izquierdo con una llamada a ayudantepostorden 2. Recorrer el subárbol derecho con una llamada a ayudantepostorden 3. Procesar el valor en el nodo El recorrido postorden procesa el valor en cada nodo después de procesar los valores de todos los hijos de ese nodo. El árbol de búsqueda binaria facilita la eliminación de valores duplicados. Al crear un árbol, la operación de inserción reconoce los intentos de insertar un valor duplicado, ya que éste sigue las mismas decisiones de ir a la izquierda o ir a la derecha en cada comparación, al igual que el valor original. Por lo tanto, la operación de inserción eventualmente comparará el valor duplicado con un nodo que contenga el mismo valor. En este punto, la operación de inserción puede decidir descartar el valor duplicado (como lo hicimos en esta sustentacion).
/** * Universidad del Quindío Estructuras de Datos Árbol de búsqueda binaria * @authores * Mauricio Duque * German Ramirez */ public class PruebaArbol public static void main(string[] args) Arbol arbol = new Arbol(); int valor; Random numeroaleatorio = new Random(); System.out.println( "Insertando los siguientes valores: " ); // inserta 10 enteros aleatorios de 0 a 99 en arbol for ( int i = 1; i <= 10; i++ ) } // fin de main } // fin de for } // fin de la clase PruebaArbol valor = numeroaleatorio.nextint( 100 ); System.out.print( valor + " " ); arbol.insertarnodo( valor ); System.out.println ( "\n\nrecorrido preorden" ); arbol.recorridopreorden(); // realiza recorrido preorden de arbol System.out.println ( "\n\nrecorrido inorden" ); arbol.recorridoinorden(); // realiza recorrido inorden de arbol System.out.println ( "\n\nrecorrido postorden" ); arbol.recorridopostorden(); // realiza recorrido postorden de arbol System.out.println ( "\n\ncontar Nodos" ); System.out.println( arbol.contarnodos() ); // realiza recorrido Contar nodos System.out.println ( "\n\ncontar Hijos" ); System.out.println( arbol.contarhijos() ); // realiza recorrido Contar hijos System.out.println ( "\n\ncontar Hermanos" ); System.out.println( arbol.contarhermanos() ); // realiza recorrido Contar hermanos System.out.println ( "\n\ncontar Nivel" ); System.out.println( arbol.contarnivel() ); // realiza recorrido Contar nivel System.out.println ( "\n\ncontar Raices" ); System.out.println( arbol.contarraices() ); // realiza recorrido Contar raices System.out.println ( "\n\ncontar Hojas" ); System.out.println( arbol.contarhojas() ); // realiza recorrido Contar hojas System.out.println(); -------------------------------------------------------------///////////////////////////////////////////////////////////////////////-----------------------------------------------------
public class Arbol // Atributos private NodoArbol raiz; // el constructor inicializa un Arbol vacio de enteros public Arbol() raiz = null; } // fin del constructor de Arbol sin argumentos // inserta un nuevo nodo en el arbol de busqueda binaria public void insertarnodo( int valorinsertar ) if ( raiz == null ) else raiz = new NodoArbol( valorinsertar ); // crea el nodo raiz aqui raiz.insertar( valorinsertar ); // llama al metodo insertar } // fin del metodo insertarnodo // Comienza el recorrido preorden public void recorridopreorden() ayudantepreorden( raiz ); } // fin del metodo recorridopreorden // metodo recursivo para realizar el recorrido preorden private void ayudantepreorden( NodoArbol nodo ) //caso base del metodo return; System.out.printf( "%d ", nodo.datos ); // imprime los datos del nodo ayudantepreorden( nodo.nodoizq ); ayudantepreorden( nodo.nododer ); } // fin del metodo ayudantepreorden // Comienza recorrido inorden public void recorridoinorden() ayudanteinorden( raiz ); } // fin del metodo recorridoinorden // metodo recursivo para realizar el recorrido inorden private void ayudanteinorden( NodoArbol nodo ) return; ayudanteinorden( nodo.nodoizq ); System.out.printf( "%d ", nodo.datos ); // imprime los datos del nodo ayudanteinorden( nodo.nododer ); } // fin del metodo ayudanteinorden
// Comienza recorrido postorden public void recorridopostorden() ayudantepostorden( raiz ); } // fin del metodo recorridopostorden // metodo recursivo para realizar el recorrido postorden private void ayudantepostorden( NodoArbol nodo ) return; ayudantepostorden( nodo.nodoizq ); ayudantepostorden( nodo.nododer ); System.out.printf( "%d ", nodo.datos ); // imprime los datos del nodo } // fin del metodo ayudantepostorden //metodo que permite contar nodos del arbol public int contarnodos() return ayudantecontarnodos( raiz ); } // fin del metodo contarnodos // metodo recursivo para contar todos los nodos del arbol private int ayudantecontarnodos( NodoArbol nodo ) int hijosizquierdo = ayudantecontarnodos( nodo.nodoizq ); int hijosderecho = ayudantecontarnodos( nodo.nododer ); return hijosizquierdo+hijosderecho+1; } // fin del metodo ayudantecontarnodos //metodo que permite contar nodos hijos del arbol public int contarhijos() int nodos = ayudantecontarnodos( raiz ); if( nodos <= 1 ) } else return nodos-1; } } // fin del metodo contarhijos // metodo para contar todos los nodos hermanos del arbol public int contarhermanos() return ayudantecontarhermanos( raiz ); } // fin del metodo contarhermanos // metodo recursivo que permite contar todos los nodos hermanos del arbol private int ayudantecontarhermanos( NodoArbol nodo )
int hermanos = 0; if( nodo.nodoizq!= null && nodo.nododer!= null ) hermanos += 2; hermanos += ayudantecontarhermanos( nodo.nodoizq ); hermanos += ayudantecontarhermanos( nodo.nododer ); return hermanos; } // fin del metodo ayudantecontarhermanos // metodo para contar los niveles del arbol public int contarnivel() return ayudantecontarnivel( raiz )-1; } // fin del metodo recorridopostorden // metodo recursivo que permite contar todos los niveles del arbol private int ayudantecontarnivel( NodoArbol nodo ) int nivelizquierdo = ayudantecontarnivel( nodo.nodoizq ); int nivelderecho = ayudantecontarnivel( nodo.nododer ); if( nivelizquierdo > nivelderecho ) return nivelizquierdo+1; else if( nivelizquierdo < nivelderecho ) return nivelderecho+1; else return nivelderecho+1; } // fin del metodo ayudantecontarnivel // metodo para contar todos los nodos raiz del arbol public int contarraices() return ayudantecontarraices( raiz ); } // fin del metodo contarraices // metodo recursivo que permite contar todos los nodos raiz del arbol private int ayudantecontarraices( NodoArbol nodo ) int raices = 0; if( nodo.nodoizq!= null nodo.nododer!= null ) raices ++; raices += ayudantecontarraices( nodo.nodoizq ); raices += ayudantecontarraices( nodo.nododer ); return raices; } // fin del metodo ayudantecontarraices // metodo para contar todos los nodos hojas del arbol public int contarhojas() return ayudantecontarhojas( raiz ); } // fin del metodo contarhojas
// metodo recursivo que permite contar todos los nodos hojas del arbol private int ayudantecontarhojas( NodoArbol nodo ) int hojas = 0; if( nodo.nodoizq == null && nodo.nododer == null ) hojas ++; hojas += ayudantecontarhojas( nodo.nodoizq ); hojas += ayudantecontarhojas( nodo.nododer ); return hojas; } // fin del metodo ayudantecontarhojas } // fin de la clase Arbol -------------------------------------------------------------///////////////////////////////////////////////////////////////////////----------------------------------------------------- public class NodoArbol // Atributos NodoArbol nodoizq; // nodo izquierdo int datos; // valor del nodo NodoArbol nododer; // nodo derecho // El constructor inicializa los datos y hace de este nodo un nodo raiz public NodoArbol( int datosnodo ) datos = datosnodo; nodoizq = nododer = null; // el nodo no tiene hijos } // fin del constructor de NodoArbol // localiza el punto de insercion e inserta un nuevo nodo; ignora los valores duplicados public void insertar( int valorinsertar ) // inserta en el subarbol izquierdo if ( valorinsertar < datos ) if ( nodoizq == null ) nodoizq = new NodoArbol( valorinsertar ); else // continua recorriendo el subarbol izquierdo nodoizq.insertar( valorinsertar ); } // fin de if else if ( valorinsertar > datos ) // inserta en el subarbol derecho } // fin de else if } // fin del metodo insertar } // fin de la clase NodoArbol if ( nododer == null ) nododer = new NodoArbol( valorinsertar ); else // continua recorriendo el subarbol derecho nododer.insertar( valorinsertar );