Informe de árbol

1. República Bolivariana de Venezuela
Instituto Universitario de Tecnología
“Antonio José de Sucre”
Anaco, Estado Anzoátegui
Cátedra: Procesamiento de datos
Carrera: Informática
DECLARACIÓN DE ARBOLES
Bachiller:
Daniel Castro
C.I 31556482
Docente:
Naudy Albornoz
Anaco, febrero 2024

2. Definición instructiva y formal de la estructura de árbol.
Una estructura de árbol es una estructura de datos no lineal que
consiste en un conjunto de nodos conectados de manera jerárquica.
La estructura de árbol consta de uno o más nodos, donde un nodo se
designa como el nodo raíz y los demás nodos se organizan en niveles,
con cada nodo teniendo un único nodo padre, excepto el nodo raíz
que no tiene padre. Cada nodo puede tener cero o más nodos hijos, y
los nodos que no tienen hijos se denominan nodos hoja.
Formalmente, un árbol se define como un conjunto finito de nodos que
satisface las siguientes condiciones:
1. Existe un nodo especial llamado "nodo raíz" que no tiene padre y es
el único nodo que no tiene un nodo padre.
2. Cada nodo distinto del nodo raíz tiene exactamente un nodo padre.
3. Cada nodo puede tener cero o más nodos hijos, y estos hijos
forman conjuntos disjuntos entre sí.
Además, en un árbol, la distancia entre el nodo raíz y cualquier otro
nodo se denomina "nivel" del nodo, y la altura del árbol es la longitud
máxima desde el nodo raíz a cualquier nodo hoja.
La estructura de árbol es ampliamente utilizada en informática para
representar relaciones jerárquicas entre datos, como la estructura de
directorios en un sistema de archivos, la representación de árboles
genealógicos, la organización de datos en bases de datos, entre otros
usos.

3. Concepto de Árbol binario. Ejemplos:
Un árbol binario es una estructura de datos en la que cada nodo tiene
como máximo dos nodos hijos, denominados "hijo izquierdo" y "hijo
derecho". Cada nodo puede tener cero, uno o dos hijos. Un árbol
binario se caracteriza por su capacidad para representar de manera
eficiente una gran variedad de estructuras jerárquicas.
Un ejemplo común de un árbol binario es el árbol de búsqueda binaria,
que se utiliza para almacenar y buscar datos de manera eficiente. En
un árbol de búsqueda binaria, los nodos se organizan de manera que
para cada nodo, todos los nodos en el subárbol izquierdo tienen
valores menores que el nodo actual, y todos los nodos en el subárbol
derecho tienen valores mayores que el nodo actual.
Otro ejemplo de un árbol binario es la estructura de un árbol de
expresión, donde cada nodo representa un operador o un operando, y
los nodos hijos representan los operandos de la operación. Este tipo
de árbol se utiliza para representar y evaluar expresiones matemáticas
de manera eficiente.

4. Recorrido del árbol binario: Operaciones con árbol binario.
El recorrido de un árbol binario se refiere a la forma en que se visitan
los nodos del árbol. Hay tres formas principales de recorrer un árbol
binario: recorrido en orden (in-order), recorrido en preorden (pre-order)
y recorrido en postorden (post-order). Cada uno de estos recorridos
tiene aplicaciones específicas y puede utilizarse para realizar
diferentes operaciones con el árbol binario.
1. Recorrido en orden (in-order):
En el recorrido en orden, primero se visita el subárbol izquierdo,
luego el nodo raíz y finalmente el subárbol derecho. Este tipo de
recorrido es útil para visitar los nodos de un árbol binario en
orden ascendente si los nodos contienen valores numéricos.
También se utiliza para realizar operaciones como la impresión
de nodos en orden ascendente, la evaluación de expresiones
matemáticas representadas por el árbol, entre otras.
2. Recorrido en preorden (pre-order):
En el recorrido en preorden, primero se visita el nodo raíz, luego
el subárbol izquierdo y finalmente el subárbol derecho. Este tipo
de recorrido es útil para copiar un árbol, para generar una
expresión prefija a partir de un árbol de expresión, o para realizar
operaciones que requieran visitar los nodos raíz antes que los
nodos hijos.
3. Recorrido en postorden (post-order):
En el recorrido en postorden, primero se visita el subárbol
izquierdo, luego el subárbol derecho y finalmente el nodo raíz.
Este tipo de recorrido es útil para liberar la memoria ocupada por
un árbol, para evaluar expresiones matemáticas representadas
por el árbol, o para realizar operaciones que requieran visitar los
nodos hijos antes que el nodo raíz.
Estos recorridos son fundamentales para realizar operaciones con un
árbol binario, ya que permiten visitar y procesar los nodos de manera
ordenada según la estructura jerárquica del árbol. Dependiendo de la
aplicación, se elegirá el tipo de recorrido más adecuado para realizar
las operaciones deseadas.

5. Búsqueda de un elemento dentro de una estructura de árbol:
Para buscar un elemento dentro de una estructura de árbol, se puede
utilizar un algoritmo de búsqueda en profundidad (DFS) o un algoritmo
de búsqueda en amplitud (BFS). Aquí te explico cómo funcionan
ambos algoritmos:
1. Búsqueda en Profundidad (DFS): En este algoritmo, se explora
cada rama del árbol hasta llegar al nodo objetivo o hasta que se haya
explorado todo el árbol. Se puede implementar de forma recursiva o
utilizando una pila (stack) para almacenar los nodos a explorar.
- Implementación recursiva: En este caso, se comienza explorando
el nodo raíz y luego se exploran recursivamente los nodos hijos en
profundidad. Si se encuentra el elemento buscado, se retorna el nodo
que lo contiene. Si se llega a un nodo hoja y no se ha encontrado el
elemento, se retrocede y se continúa explorando otros nodos.
- Implementación con pila: En este caso, se comienza explorando el
nodo raíz y se van apilando los nodos hijos a medida que se van
explorando. Se saca un nodo de la pila, se verifica si es el elemento
buscado y, si no lo es, se exploran sus hijos y se van apilando. Este
proceso se repite hasta encontrar el elemento o hasta que la pila esté
vacía.
2. Búsqueda en Amplitud (BFS): En este algoritmo, se explora cada
nivel del árbol de forma secuencial, comenzando por el nivel más
cercano al nodo raíz. Se puede implementar utilizando una cola
(queue) para almacenar los nodos a explorar.
- Implementación con cola: En este caso, se comienza explorando el
nodo raíz y se van encolando los nodos hijos a medida que se van
explorando. Se saca un nodo de la cola, se verifica si es el elemento
buscado y, si no lo es, se encolan sus hijos. Este proceso se repite
hasta encontrar el elemento o hasta que la cola esté vacía.

6. Ordenamiento:
El ordenamiento en una estructura de árbol se refiere a la manera en
que se organizan los elementos dentro de ese árbol. En un árbol, cada
nodo puede tener uno o varios hijos, y el ordenamiento determina la
posición relativa de esos hijos con respecto al nodo padre.
Existen diferentes técnicas de ordenamiento que se pueden aplicar a
los árboles, dependiendo de la implementación específica del árbol.
Algunas formas comunes de ordenamiento en árboles incluyen:
1. Árbol binario de búsqueda (BST): En un BST, el ordenamiento se
logra siguiendo una regla específica: todos los valores menores que el
valor de un nodo se almacenan en su subárbol izquierdo, y todos los
valores mayores se almacenan en su subárbol derecho. Esto facilita la
búsqueda y recuperación eficiente de información dentro del árbol.
2. Árbol AVL: Un AVL es un tipo especial de árbol binario de búsqueda
que está balanceado automáticamente. El ordenamiento en un AVL se
mantiene mediante la rotación de nodos para mantener la altura del
árbol lo más equilibrada posible. Esto asegura que las operaciones de
inserción y eliminación sean muy eficientes.
3. Árbol B: Un árbol B es otro tipo de árbol balanceado que se utiliza
para almacenar grandes cantidades de datos. En un árbol B, los datos
se organizan en nodos que tienen múltiples claves y múltiples hijos.
Cada nodo tiene una cantidad mínima y máxima de claves, lo que
permite un ordenamiento eficiente de los elementos.

7. Programa para utilizar árboles. (Python):
class Nodo:
def __init__(self, valor):
self.valor = valor
self.izquierda = None
self.derecha = None
def insertar(raiz, valor):
if raiz is None:
return Nodo(valor)
else:
if valor < raiz.valor:
raiz.izquierda = insertar(raiz.izquierda, valor)
else:
raiz.derecha = insertar(raiz.derecha, valor)
return raiz
def inorder(raiz):
if raiz:
inorder(raiz.izquierda)
print(raiz.valor)
inorder(raiz.derecha)
raiz = None
raiz = insertar(raiz, 10)

8. raiz = insertar(raiz, 5)
raiz = insertar(raiz, 15)
raiz = insertar(raiz, 3)
raiz = insertar(raiz, 7)
print("Recorrido inorder del árbol:")
inorder(raiz)