INSTITUTO TECNOLOGICO NACIONAL DE MEXICO

INSTITUTO TECNOLOGICO DE ORIZABA

“INFORMATICA”

“ESTRUCTURA DE DATOS”

REPORTE DE UNIDAD IV “ESTRUCTURAS NO LINEALES

(ARBOLES)”

GRUPO:
3a3

PRESENTA:
MARTINEZ FLORES MOISES
RAMIREZ CAMARENA KEVIN OSCAR

HORA: 15:00 – 16:00

06/JUNIO/2021
INTRODUCCION.

Un árbol es una estructura jerárquica de datos que imita la forma

de un árbol, un conjunto de nodos conectados. Un nodo es la
unidad sobre la que se construye el árbol y puede tener ceros o
mas nodos hijos conectados a él. Se dice que un nodo a es padre
de un nodo b si existe un enlace desde a hasta b. Solo puede haber
un único nodo sin padres, que llamaremos raíz. Un nodo que no
tiene hijos se conoce como hoja y a los demás nodos se les conoce
como ramas.
Formalmente, un árbol se puede definir de manera recursiva, se
utiliza la recursión para definir un árbol porque es una
característica inherente a los mismos, como:

• Un solo nodo es, por si mismo, un árbol. Ese nodo es también

la raíz de dicho árbol.

• Se supone que n es un nodo y que, A 1 A2,..., Ak son arboles

con raíces n1, n2,…, nk respectivamente. Se puede construir
un nuevo árbol haciendo que n se constituya en el padre de,
los nodos n1, n2,…, nk. En dicho árbol, n es la raíz y A1 A2,...,
Ak son los subarboles (o arboles hijos) de la raíz. Los nodos
n1, n2 ,… ,nk reciben el nombre de hijos del nodo n y el nodo n
recibe el nombre de padre de dichos nodos

Como ejemplo se puede considerar el índice de un libro.

T1 (Tema 1)
1.1.-(Pregunta 1 del Tema 1)

1.2.-(Pregunta 2 del Tema 1)

T2 (Tema 2)
2.1.-(Pregunta 1 del Tema 2)
2.1.1.-(Pregunta 1 de la pregunta 1 del Tema 2)
2.1.2.-( Pregunta 2 de la pregunta 1 del Tema 2)
2.2.-(Pregunta 2 del Tema 2)
2.3.-(Pregunta 3 del Tema 2)
T3 (Tema 3)
 T

T1 T2 T3

1.1 1.2 2.1 2.2 2.3

2.1.1 2.1.2

Los atributos de un árbol son los siguientes:

• El grado de un nodo es el número de subarboles que tiene. En nuestro
ejemplo el grado de T2 es 3. Por lo tanto son nodos terminales u hojas los
nodos de grado 0.
• La altura de un nodo es la longitud del camino más largo de ese nodo a una
hoja.
• El nivel o profundidad de un nodo es la longitud del único camino desde la
raíz a ese nodo. Por definición la raíz tiene nivel 0. La profundidad de un árbol
se define como el máximo de los niveles de los nodos del árbol.
Marco teórico.
¿Qué es un árbol?
Un árbol es una estructura no lineal en la que cada nodo puede apuntar a uno o
varios nodos. También se suele dar una definición recursiva: un árbol es una
estructura en compuesta por un dato y varios árboles. Esto son definiciones simples.
Pero las características que implican no lo son tanto.
Un árbol es una estructura no lineal en la que cada nodo puede apuntar a uno o
varios nodos. También se suele dar una definición recursiva: un árbol es una
estructura en compuesta por un dato y varios árboles. Esto son definiciones simples.
Pero las características que implican no lo son tanto.

Clasificación de árboles
Existen cuatro tipos de árbol binario:
A. B. Distinto.
A. B. Similares.
A. B. Equivalentes.
A. B. Completos.
A continuación, se hará una breve descripción de los diferentes tipos de árbol}
binario, así como un ejemplo de cada uno de ellos.
A. B. DISTINTO
Se dice que dos árboles binarios son distintos cuando sus estructuras son
diferentes.
A. B. SIMILARES
Dos árboles binarios son similares cuando sus estructuras son idénticas, pero la
información que contienen sus nodos es diferente.
A. B. EQUIVALENTES
Son aquellos árboles que son similares y que además los nodos contienen la misma
información.
A. B. COMPLETOS
Son aquellos árboles en los que todos sus nodos excepto los del ultimo nivel, tiene
dos hijos; el subárbol izquierdo y el subárbol derecho.

Operaciones básicas sobre arboles binarios

Salvo que trabajemos con árboles especiales, como los que veremos más adelante,
las inserciones serán siempre en punteros de nodos hoja o en punteros libres de
nodos rama. Con estas estructuras no es tan fácil generalizar, ya que existen
muchas variedades de árboles.
De nuevo tenemos casi el mismo repertorio de operaciones de las que disponíamos
con las listas:

• Añadir o insertar elementos.

• Buscar o localizar elementos.
• Borrar elementos.
• Moverse a través del árbol.
• Recorrer el árbol completo.

Los algoritmos de inserción y borrado dependen en gran medida del tipo de árbol
que estemos implementando, de modo que por ahora los pasaremos por alto y nos
centraremos más en el modo de recorrer árboles.

Aplicaciones
Un ejemplo de estructura en árbol es el sistema de directorios y ficheros de un
sistema operativo. Aunque en este caso se trata de árboles con nodos de dos tipos,
nodos directorio y nodos archivo, podríamos considerar que los nodos hoja son
archivos y los nodos rama son directorios. Otro ejemplo podría ser la tabla de
contenido de un libro, por ejemplo de este mismo manual, dividido en capítulos, y
cada uno de ellos en subcapítulos. Aunque el libro sea algo lineal, como una lista,
en el que cada capítulo sigue al anterior, también es posible acceder a cualquier
punto de él a través de la tabla de contenido. También se suelen organizar en forma
de árbol los organigramas de mando en empresas o en el ejército, y los árboles
genealógicos.

Características de los árboles

• Hijo: Es aquel nodo que siempre va a tener un nodo antecesor o padre, son
aquellos que se encuentran en el mismo nivel
• Padre: Es aquel que tiene hijos y también puede tener o no antecesores.
• Hermano: Dos nodos son hermanos si son apuntados por el mismo nodo, es
decir si tienen el mismo padre.
• Raíz: Es el nodo principal de un árbol y no tiene antecesores.
• Hoja o terminal: Son aquellos nodos que no tienen hijos o también los nodos
 finales de un árbol.
• Interior: Se dice que un nodo es interior si no es raíz ni hoja.
• Nivel de un nodo: Se dice que el nivel de un nodo es el numero de arcos que
deben ser recorridos, partiendo de la raíz para llegar hasta el.
• Altura del árbol: Se dice que la altura de un árbol es el máximo de los niveles
considerando todos sus nodos.
• Grado de un nodo: se dice que el grado de un nodo es el número de hijos
que tiene dicho nodo.

Tipos de Árboles
• Árboles Binarios: Un árbol binario es un conjunto finito de elementos, el cual
está vacío o dividido en tres subconjuntos separados: raíz del árbol, subárbol
izquierdo y subárbol derecho
• Árbol de búsqueda binario auto-balanceable: Es el que intenta mantener su
altura, o el número de niveles de nodos bajo la raíz, tan pequeños como sea
posible en todo momento, automáticamente
• Árboles AVL: están siempre equilibrados de tal modo que para todos los
nodos, la altura de la rama izquierda no difiere en más de una unidad de la
altura de la rama derecha o viceversa.
• Árboles Rojo-Negro : Un árbol rojo-negro es un árbol binario de búsqueda en
el que cada nodo tiene un atributo de color cuyo valor es rojo o negro.
• Árboles AA: utilizado para almacenar y recuperar información ordenada de
manera eficiente
• Árbol de segmento: es una estructura de datos en forma de árbol para
guardar intervalos o segmentos. Permite consultar cuál de los segmentos
guardados contiene un punto.
• Árboles Multicamino: es un árbol ordenado cuyos nodos deben tener un
número específico de hijos.
• Árboles B: Es un árbol de búsqueda que puede estar vacío o aquel cuyos
nodos pueden tener varios hijos, existiendo una relación de orden entre ellos.
Recorridos de Árboles
Preorden:

• Visitar la Raíz
• Recorrer el subarbol izquierdo
• Recorrer el subarbol derecho

Inorden:

• Recorrer el subarbol izquierdo

• Visitar la raíz
• Recorrer el subarbol derecho

Postorden:

• Recorrer el subarbol izquierdo

• Recorrer el subarbol derecho
• Visitar la raíz
Recursos, materiales y equipo
• Computadora
• IDE NETBEANS,
• JDK.
• Lectura de los materiales de apoyo del tema 1 (AULA MOODLE, O Link de
Consulta)
• Clase Tools.
COMPETENCIAS.
Específica(s):
Comprende y aplica estructuras no lineales para la solución de problemas.
Genéricas:

• Habilidad para buscar y analizar información proveniente de fuentes

diversas.
• La comprensión y manipulación de ideas y pensamientos.
• Metodologías para solución de problemas, organización del tiempo y para el
aprendizaje.
• Habilidad en el manejo de equipo de cómputo
• Capacidad para trabajar en equipo.
• Capacidad de aplicar los conocimientos en la práctica.
Arboles practicas elaboradas.
En esta unidad elaboramos un program donde se pudiera hacer un arbol mediante
los pasos que se recoimiendan y sobre todo siguiendo las reglas y las maneras
en que se puedan

Paso 1.- primero debemos de crear un Proyecto nuevo y agregamos 3 paquetes

1. Paquete 1.- EntradaSalida
2. Paquete 2.- MemoriaDinamica
3. Paquete 3.- Main

Paso 2.- creamos las clases dentro de los paquetes.

Clases.-

TOOLS:

package EntradaSalida;
import javax.swing.JOptionPane;
import javax.swing.JTextArea;
public class Tools {
public static int leerInt(String msje) {
int num = 0;
boolean r = true;
do {
try {
num = (Integer.parseInt(JOptionPane.showInputDialog(null, msje, "dame
un valor", JOptionPane.INFORMATION_MESSAGE)));
r = false;
} catch (NumberFormatException e) {
Tools.errorMsje("error: ingrese valor valido, no vacios ni use decimales
o letras");
}
} while (r);
return num;
}

public static double leerDouble(String msje) {

double num = 0;
boolean r = true;
do {
try {
 num = (Double.parseDouble(JOptionPane.showInputDialog(null, msje,
"dame un valor", JOptionPane.INFORMATION_MESSAGE)));
r = false;
} catch (NumberFormatException e) {
Tools.errorMsje("error: ingrese valor valido, no espacios vacios ni use
letras");
}
} while (r);
return num;
}
public static float leerFloat(String msje) {
float num = 0;
boolean r = true;
do {
try {
num = (Float.parseFloat(JOptionPane.showInputDialog(null, msje,
"dame un valor", JOptionPane.INFORMATION_MESSAGE)));
r = false;
} catch (NumberFormatException e) {
Tools.errorMsje("error: ingrese valor valido, espacios vacios ni use
letras");
}
} while (r);
return num;
}
public static Byte leerByte(String msje) {
byte num = 0;
boolean r = true;
do {
try {
 num = (Byte.parseByte(JOptionPane.showInputDialog(null, msje, "dame
un valor", JOptionPane.INFORMATION_MESSAGE)));
r = false;
} catch (NumberFormatException e) {
Tools.errorMsje("error: ingrese valor valido, espacios vacios ni use
decimales o letras");
}
} while (r);
return num;
}
// Les recuerdo que udes deben complementar las Entrada de datos de enteros y
reales..tipos de datos de java

public static char leerChar(String msje) {// lectura de un caracter

return (JOptionPane.showInputDialog(null, msje).charAt(0));
}
public static String leerString(String msje) { //Lectura de una cadena
return (JOptionPane.showInputDialog(null, msje));
}
public static String leerName(String msje) { // lectura de un nombre con
validacion
String cad;
do {
cad = JOptionPane.showInputDialog(null, msje);
if (cad.matches("([a-z]|[A-Z]|\\s)+")) {
return cad;
} else {
JOptionPane.showMessageDialog(null, msje + " contiene caracteres no
validos");
}
 } while (!cad.matches("([a-z]|[A-Z]|\\s)+"));

return cad;
}
// Mensajes de salida
public static void imprimeMsje(String msje) { // Salida de mensaje
JOptionPane.showMessageDialog(null, msje, "salida",
JOptionPane.INFORMATION_MESSAGE)}
public static void errorMsje(String msje) { // Salida de mensaje de error
JOptionPane.showMessageDialog(null, msje, "intenta de nuevo",
JOptionPane.ERROR_MESSAGE);
}
public static void imprimeAreaTexto(String cad) {//Salida en una area de texto
con scroll
JTextArea areaSalida = new JTextArea(10, 4);
JScrollPane scroller = new JScrollPane(areaSalida);
areaSalida.setText("\n" + cad);
JOptionPane.showMessageDialog(null, scroller, "SALIDA",
JOptionPane.INFORMATION_MESSAGE);
}
public static int SiNo() { // Botones se pueden usar en ciclos o en switch
return (JOptionPane.showConfirmDialog(null, "deseas continuar",
"capturando de objetos", JOptionPane.YES_NO_OPTION));
}
// Metodos que permiten seleccionar un dato especifico cuando el ejercicio indica
items a considerar. Modelo que les puede servir para crear nuevos metodos.

public static char genero(String msje) {

Object[] valores = {'M', 'F'};
char res = (char) JOptionPane.showInputDialog(null, msje, "Selecciona",
JOptionPane.INFORMATION_MESSAGE, null, valores, valores[0]);
 return (res);
}
public static String carrera(String msje) { //Metodo que permite seleccionar una
carrera, debera de agregar las carreras que oferta el Tec
Object valores[] = {"Ing. Sistemas Computacionales", "Ing. Quimica", "Ing.
Informatica, Ing. Industrial, Ing. Electronica"};
String res = (String) JOptionPane.showInputDialog(null, msje, "Selecciona",
JOptionPane.INFORMATION_MESSAGE, null, valores, valores[0]);
return res;
}
public static String color() {
Object valores[] = {"Verde", "Rojo", "Azul Metálico", "Negro", "Blanco"};
String res = (String) JOptionPane.showInputDialog(null, "Gama de Colores", "
Selecciona:", JOptionPane.QUESTION_MESSAGE, null, valores, valores[0]);
return (res);
}
public static int semestre(String msje) {
Object[] valores = {1, 2, 3, 5, 6, 7, 8, 9, 10, 11, 12};
int res = (int) JOptionPane.showInputDialog(null, msje, "Selecciona",
JOptionPane.QUESTION_MESSAGE, null, valores, valores[0]);
return (res);
}
public static String numctrl() {

String ctrl;
do {
ctrl = leerString("Ingresa tu numero de control");
ctrl = ctrl.trim();
if (ctrl.matches("[0-9]{8}")) {
return ctrl;
 } else {
Tools.errorMsje("Recuerda que el numero de control son de 8 digitos");
}
} while (!ctrl.matches("[0-9]{8}"));
return ctrl;
}
}

CLASE ARBOL:

package MemoriaDinamica;
public class Arbol<T extends Comparable<T>> {
private Nodito raiz;//tiene enlazados a todos los nodos
public Arbol() {
raiz = null;
}

//ARBOL VACIO
public boolean ArbolVacio() {
return (raiz == null);
}

//METODO INSERTAR
public void insertarDato(T dato) {
Nodito p = new Nodito(dato);
if (ArbolVacio()) {
raiz = p; //Busca el nodo padre
} else {
Nodito padre = buscaPadre(raiz, p);
if (p.getDato().compareTo(padre.getDato()) >= 0) {
 padre.setDer(p); //inserta nodo hijo Derecha
} else {
padre.setIzq(p); //inserta nodo hijo Izquierda
}
}
}

// METODO BUSCAR PADRE

public Nodito buscaPadre(Nodito antes, Nodito p) {
Nodito padre = null;
while (antes != null) {
padre = antes;
if (p.getDato().compareTo(padre.getDato()) >= 0) //localiza nodo padre
{
antes = antes.getDer(); //recorre por sub arbol derecho
} else {
antes = antes.getIzq(); //recorre el sub arbol izquierdo
}
}
return padre;
}

// METODO PRE-ORDEN
public String preorden(Nodito r) {

if (r != null) {
return r.getDato() + "-- " + preorden(r.getIzq()) + " " + preorden(r.getDer())
+ " ";
} else {
 return "";
}
}

// METODO POST-ORDEN
public String postorden(Nodito r) {
if (r != null) { //REGLA IZQUIERDA, DERECHA, VISITA R RAIZ
return postorden(r.getIzq()) + "-- " + postorden(r.getDer()) + " " + r.getDato()
+ " ";
} else {
return " ";
}
}

// METODO RECORRIDOS
public String recorridos() {
return "Modo pre-orden:\n" + preorden(raiz);
/*+ "\nModo postorden:\n" + postorden(raiz) + "\n\nModo in-orden 1:\n"
+ inOrden1(raiz) + "\n\n Modo in-orden 2:\n" + inOrden2(raiz) + "\n\n
Modo interno :\n" + interno(raiz)
+ "\n\n Modo externo:\n" + externo(raiz);*/
}

// METODO NODOS INTERNOS

public String interno(Nodito r) {
if (r != null) {

if (r.getIzq() != null || r.getDer() != null) {

return r.getDato() + "-- " + interno(r.getIzq()) + " " + interno(r.getDer()) +
" ";
} else {
 return "";
}
} else {
return "";
}
}

// METODO NODOS TERMINALES

public String externo(Nodito r) {
if (r != null) {
if (r.getDer() == null && r.getIzq() == null) {
return r.getDato() + "-- ";
} else {
return externo(r.getDer()) + "--" + externo(r.getIzq()) + " ";
}
} else {
return " ";
}
}

// METODO IN-ORDEN
public String inOrden1(Nodito r) {
if (r != null) { //REGLA IZQUIERDA, RAIZ, DERECHA
return inOrden1(r.getIzq()) + "-- " + r.getDato() + " " + inOrden1(r.getDer())
+ " ";
} else {
return " ";
}
}
// METODO IN-ORDEN2
public String inOrden2(Nodito r) {
if (r != null) { //REGLA DERECHA, RAIZ, IZQUIERDA
return inOrden2(r.getDer()) + "-- " + r.getDato() + " " + inOrden2(r.getIzq())
+ "-- ";
} else {
return " ";
}
}

// METODO BUSCAR NODO

//BUSCAR NODO
public Nodito busqueda(T dato) {
Nodito r = raiz;
while (r != null && !r.getDato().equals(dato)) {
if (r.getDato().compareTo(dato) >= 0) {
r = r.getDer();
} else {
r = r.getIzq();
}
}
if (r != null && dato.equals(r.getDato())) {
return r;
} else {
return (null);
}
}
}
CLASE NODITO:
package MemoriaDinamica;
public class Nodito <T extends Comparable <T>>{
private T dato;
private Nodito<T> izq;
private Nodito<T> der;
public Nodito()
{
izq=null;
der=null;
}
public Nodito(T dato)
{
this.dato = dato;
izq=null;
der=null;
}
// generar metodos setter/getter

public T getDato() {
return dato;
}
public void setDato(T dato) {
this.dato = dato;
}
public Nodito<T> getIzq() {
return izq;
}
 public void setIzq(Nodito<T> izq) {
this.izq = izq;
}
public Nodito<T> getDer() {
return der;
}
public void setDer(Nodito<T> der) {
this.der = der;
}
}

CLASE MAIN:
package tema_4;
import EntradaSalida.Tools;
import MemoriaDinamica.Arbol;
import MemoriaDinamica.Nodito;
import javax.swing.JOptionPane;
public class Tema_4 {
public static void main(String args[]) {
menu();
}
public static void menu() {
Arbol arbol = new Arbol();
String p;
String opcion[] = {"INSERTAR", "ELIMINAR TERMINAL", "BUSCAR",
"LIMPIAR", "SALIR"};
int sel;
do {
 sel = JOptionPane.showOptionDialog(null, " SELECCIONA DANDO
CLICK ", " M E N U", JOptionPane.NO_OPTION,
JOptionPane.QUESTION_MESSAGE, null, opcion, opcion[0]);
switch (opcion[sel]) {
case "INSERTAR":
arbol.insertarDato(Tools.leerInt("inserta el numero"));
Tools.imprimeMsje("Arbol binario:\n" + arbol.recorridos());
break;
case "ELIMINAR TERMINAL":
break;
case "BUSCAR":
Nodito buscar = arbol.busqueda(Tools.leerInt("Dato a buscar"));
if (buscar != null) {
Tools.imprimeMsje("El dato si existe en el arbol: " +
buscar.getDato());
} else {
Tools.errorMsje("El dato no se encuentra en el arbol");
}
break;
case "ELIMINAR":

break;

case "SALIR":
Tools.imprimeMsje("Fin del programa");
break;
}
} while (!"SALIR".equals(opcion[sel]));}
}
RESULTADOS:
CONCLUSION:
Luego de concluir el siguiente tema, debemos tener en cuenta que un árbol como
estructura de datos nos permite almacenar una cantidad significativa de datos de
forma ordenada. Un árbol se representa con un conjunto de nodos entrelazados
entre sí por medio de ramas, debemos tener en cuenta que el nodo base es único,
y se le denomina raíz. En un árbol un padre puede tener varios hijos pero un hijo
solo puede tener un padre. Desde la raíz se puede llegar a cualquier nodo
progresando por las ramas y atravesando los sucesivos niveles estableciendo así
un camino.

Los recorridos de un árbol se entienden por el tratamiento realizado para acceder

a los diferentes nodos de un árbol. El recorrido puede afectar a la totalidad de los
nodos del árbol, por eso debemos tener muy claro que al realizar un árbol
debemos colocar nombres complejos que trate del algoritmo que estamos
realizando, ya que al realizar los recorridos debemos saber dónde estamos
ubicados en dicho árbol, y cuando se vaya haciendo más extenso dicho algoritmo
que hemos creado sea más fácil de ubicarnos. Ya que si nos ubicamos mal en un
nodo podemos crear un mal funcionamiento del algoritmo, borrar información
equivocada o que ocurra un desbordamiento de datos
REFERENCIAS:
“estructura de datos” Osvaldo Cairo Silvia Guardati tercera edición.
file:///C:/Users/lenovo/Desktop/Unidad%20IV.pdf
http://www6.uniovi.es/usr/cesar/Uned/EDA/Apuntes/TAD_apUM_04.pdf