REPÚBLICA BOLIVARIANA DE VENEZUELA

MINISTERIO DEL PODER POPULAR PARA

LA EDUCACIÓN UNIVERSITARIA
INSTITUTO UNIVERSITARIO POLITÉCNICO
“SANTIAGO MARIÑO”
EXTENSIÓN MATURÍN

Estructura de Datos 2er 20%.

Tercer Corte

Autor: José Vásquez.

CI. 28.242.945
Asesor: Amelia Malavé
Sección: Virtual

Maturín, agosto 2022

1. Explicar paso a paso la función de insertar elementos a un árbol
Binario. Valor 5 ptos

En un árbol, se tiene que tener en cuenta que no se puede insertar de

manera directa, primero que nada, se deben tener en cuenta dos cosas, la
primera, que el árbol puede estar vacío, esto con: con ‘‘if (árbol ==NULL)’’
(por ejemplo), entonces, en el caso que lo este, se tiene que crear un nuevo
nodo, con ‘‘Nodo *nuevo_nodo = crearNodo(n)’’ (por ejemplo), una vez
creado, al árbol se le asigna el nuevo nodo, en este caso con ‘‘árbol =
nuevo_nodo’’. De esta forma ya se tendría el nodo raíz, que sería en este
caso ‘‘n’’.

En caso de que el árbol ya tenga un nodo, primero se tiene que saber

el valor de la raíz, ya que los elementos menores a la raíz van de lado
izquierdo y los mayores al lado derecho, entonces y, en este caso, se declara
una nueva raíz de tipo entero y se iguala a ‘‘arbol -> dato’’, esto para tener el
valor de la raíz, luego, se usa un condicional ‘‘if’’, en este caso, para
preguntar si el número que se quiere insertar: ‘‘n’’, es menor al valor de la
raíz, y, si es así va por el lado izquierdo, con insertar(árbol->izq,n).

Y en el caso de que sea mayor (else) se inserta por el lado derecho

con insertar(árbol->dec, n).

2. Explicar paso a paso una función que permita recorrer un árbol

binario (seleccione un recorrido) y dé ejemplo. Valor 5 ptos

Recorrer árbol el pre Orden

2
 Cuando hablamos de recorrer, básicamente nos referimos a visitar
cada nodo, elemento o número del árbol, de tal manera que se visite cada
uno de sus elementos una vez y, si se quiere, mostrarlo. En caso de los
arboles binarios, se puede distinguir tres tipos de recorrido, estos son:

 INORDEN
 POSTORDEN
 PREORDEN

En este caso, se hablará y se dará un ejemplo del recorrido PreOrden:

El recorrido en el orden preorden consiste básicamente en recorrer el

árbol de la siguiente manera: raíz, subárbol izquierdo y finalmente subárbol
derecho.

Ejemplo (Este ejemplo también será mostrado como capturas en el 3er

ejercicio, que es mostrar un menú con las diversas operaciones.):

3
 Siguiendo la manera de recorrer un árbol en pre orden, si iniciaría por
la raíz, que es 5, seguiríamos por el 4 y luego el 3, una vez recorrida la parte
izquierda, pasaríamos a la derecha, y se mostrarían primero el 6 y luego el 7,
en resumen, el programa mostrara lo siguiente:

5, 4, 3, 6, 7.

Entonces:

La función trabaja de forma que, si el árbol no esta vacio, se manda a impimir

la raíz, luego el subárbol izquierdo, y finalmente el subárbol derecho.

4
5
 3. Elaborar un programa que muestre un menú, las diversas
operaciones que se pueden realizar con árboles. Debe mostrar el
código editable y hacer capture de las posibles ejecuciones, insertando
datos. Valor 10 ptos

CAPTURAS:
1. AGREGAR:

6
7
2. BUSCAR

8
En caso de que no este:

3. RECORRIDO
(Se usara el árbol previamente mostrado)
Pre

9
In

Post

10
4. ELIMINAR

Eliminando el 6 del árbol mostrado:

11
5. MOSTRAR

12
6. SALIR

CODIGO EDITABLE:

#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
// Estructura de Datos 20% 3er Corte Jose Leonardo Vasquez

using namespace std;

struct nodo{

int dato;
nodo *der;
nodo *izq;
nodo *padre;
};

13
 // Funciones
void menu();
nodo *crearNodo(int, nodo *);
nodo *arbol = NULL;
void insertarNodo(nodo *&, int, nodo *);
void mostrarArbol(nodo *, int);
void preRecorrido(nodo *);
void inRecorrido(nodo *);
void postRecorrido(nodo*);
void eliminarArbol(nodo *, int);
bool buscarArbol(nodo *, int);
void eliminarNumero(nodo*);
nodo *minima(nodo *);
void reemplazo(nodo *, nodo *);
void suprimirNodo(nodo *);

int main(){

menu();

getch();
return 0;
}

void menu (){

int dato, menu, cont=0, rc;
do{
printf ("Estudiante: Jose Leonardo Vasquez,
28.242.945\n");
printf ("Menu. Operaciones basicas con Arboles\n");

14
 printf ("1. AGREGAR\n");
printf ("2. BUSCAR\n");
printf ("3. RECORRIDO \n");
printf ("4. ELIMINAR\n");
printf ("5. MOSTRAR\n");
printf ("6. SALIR\n");
scanf("%d", &menu);

switch(menu){

case 1 :
printf ("\nIntroduzca un numero \n");
scanf("%d", &dato);
insertarNodo(arbol,dato, NULL);
system("pause");

break;

case 2:
printf("Ingresa el numero a buscar: \n");
scanf("%d", &dato);
if (buscarArbol(arbol,dato) == true){
printf("Se ha encontrado el numero: %d
en el arbol\n", dato);
}
else{
printf ("Numero no encontrado\n");
}
system ("pause");
break;

15
 case 3:
printf ("Que tipo de recorrido quiere hacer?\
n");
printf("Ingrese 1 para PRE orden\n");
printf("Ingrese 2 para IN orden\n");
printf("Ingrese 3 para POST orden\n");
scanf("%d", &rc);
if (rc==1){
printf("Recorrido en pre orden: \n");
preRecorrido(arbol);
system("pause");
}
else if(rc==2){
printf("Recorrido en in orden: \n");
inRecorrido(arbol);
system("pause");
}
else if(rc==3){
printf("Recorrido Post orden: \n");
postRecorrido(arbol);
system("pause");
}
else{
printf("Numero errado, intente de
nuevo");
system("pause");
}
break;

16
 case 4 :
printf ("Cual numero desea eliminar\n");
scanf("%d", &dato);
eliminarArbol(arbol,dato);
system("pause");
break;

case 5:
printf ("Mostrar elemento de la cola\n");
mostrarArbol(arbol,cont);
system("pause");
break;

case 6 :
printf("Ha salido del programa\n");
system("pause");
break;

}
system("cls");
}
while (menu != 6);
}

// Crear un nodo en un arbol

nodo *crearNodo(int n, nodo *padre){
nodo *nuevo_nodo = new nodo();

nuevo_nodo ->dato = n;

17
 nuevo_nodo->der = NULL;
nuevo_nodo->izq = NULL;
nuevo_nodo->padre = padre;
}

// Insertar un nodo en un arbol

void insertarNodo (nodo *&arbol, int n, nodo *padre){

if (arbol == NULL){
nodo *nuevo_nodo = crearNodo(n, padre);
arbol = nuevo_nodo;
}
else {
int valorRaiz = arbol -> dato;
if (n < valorRaiz){
insertarNodo(arbol->izq, n, arbol);
}
else{
insertarNodo(arbol->der, n, arbol);
}
}
}

// Mostrar Arbol

void mostrarArbol(nodo *arbol, int contador){

if(arbol == NULL){
return;
}
else{

18
 mostrarArbol(arbol->der, contador+1);
for (int i=0; i<contador;i++){
printf (" ");
}
printf ("%d\n", arbol->dato);
mostrarArbol(arbol->izq, contador+1);
}
}

//Determinar el nodo mas izquierdo en el arbol

nodo *minima(nodo *arbol){

if (arbol == NULL){
return NULL;
}
if(arbol->izq){
return minima(arbol->izq);
}
else{
return arbol;
}
}

//Eliminar elemento del arbol

void eliminarArbol(nodo *arbol, int n){

if(arbol == NULL){
return;
}
else if(n < arbol->dato){

19
 eliminarArbol(arbol->izq, n);
}
else if (n >arbol->dato){
eliminarArbol(arbol->der,n);
}
else{
eliminarNumero(arbol);
}
}

//Eliminar numero encontrado

void eliminarNumero(nodo *eliminar){
if (eliminar->izq && eliminar->der){
nodo *menor = minima(eliminar->der);
eliminar->dato = menor->dato;
eliminarNumero(menor);
}
else if (eliminar->izq){
reemplazo(eliminar, eliminar->izq);
suprimirNodo(eliminar);
}
else if (eliminar->der){
reemplazo(eliminar, eliminar->der);
suprimirNodo(eliminar);
}
else{
reemplazo(eliminar,NULL);
suprimirNodo(eliminar);
}
}

20
// Eliminar nodo
void suprimirNodo(nodo *nodo){
nodo->izq=NULL;
nodo->der=NULL;
delete nodo;
}

// Reemplazar nodo
void reemplazo(nodo *arbol, nodo *nuevoNodo){
if (arbol->padre){
if (arbol->dato == arbol->padre->izq->dato){
arbol->padre->izq = nuevoNodo;
}
else if (arbol->dato == arbol->padre->der->dato){
arbol->padre->der = nuevoNodo;
}
}
if (nuevoNodo){

nuevoNodo->padre=arbol->padre;
}
}

//Recorrido PRE de un arbol

void preRecorrido(nodo *arbol){

if(arbol == NULL){
return;
}

21
 else{
printf (" %d, ", arbol->dato);
preRecorrido(arbol->izq);
preRecorrido(arbol->der);
}
}

//Recorrido IN de un arbol

void inRecorrido(nodo *arbol){

if (arbol==NULL){
return;
}
else{
inRecorrido (arbol->izq);
printf ("%d, ", arbol->dato);
inRecorrido (arbol->der);
}
}

//Recorrido POST de un arbol

void postRecorrido (nodo *arbol){

if (arbol==NULL){
return;
}
else{
postRecorrido (arbol->izq);
postRecorrido (arbol->der);
printf ("%d, ", arbol->dato);

22
 }
}

//Buscar en el arbol

bool buscarArbol(nodo *arbol, int n){

if (arbol==NULL){
return false;
}
else if(arbol->dato ==n){
return true;
}
else if(n < arbol->dato){
return buscarArbol(arbol->izq,n);
}
else{
return buscarArbol(arbol->der,n);
}
}

23