1 ACTIVIDAD EVALUATIVA 2

VICTOR MANUEL BOLIVAR ARIZA

FERNANDO CORONELL
MARZO 2024.

INSTITUCIÓN AREANDINA.
MODELOS DE PROGRAMACIÓN II
YASHIN ALBERTO RUEDA MATOS
 Objetivos

1. En el ejercicio el objetivo es permitir al usuario insertar una cantidad

variable de elementos en un árbol binario. Posteriormente, que ofrezca las
siguientes funcionalidades:

 Mostrar el árbol en orden.

 Mostrar los nodos en donde tiene dos hijos en orden.
 Mostrar la cantidad de nodos que tengan por lo menos un hijo que sea un
número par (en preorden).
 Por cada nodo, mostrar la suma de sus hijos (en preorden).
 Mostrar el camino para llegar al nodo X, si no existe el nodo mostrar un
mensaje “El nodo no existe”.
Ejercicio 1

En el ejercicio 1 se creó un proyecto llamado trabajo1 en el cual esta una carpeta

llamada src y dentro de esta otra carpeta llamada trabajo1 lo cual tiene 3 archivos
llamados BTS, Main y Node así como se muestra en la siguiente imagen:
En el archivo BTS tenemos el siguiente código:

package trabajo1;

class BTS {

trabajo1 root;

public BTS() {

root = null;

public void insertar(int data) {

root = insertarrecursive(root, data);

}
 private trabajo1 insertarrecursive(trabajo1 root, int

data) {

if (root == null) {

root = new trabajo1(data);

return root;

if (data < root.data) {

root.left = insertarrecursive(root.left, data);

} else if (data > root.data) {

root.right = insertarrecursive(root.right, data);

return root;

public void recorridoenorden(trabajo1 root) {

if (root != null) {
 recorridoenorden(root.left);

System.out.print(root.data + " ");

recorridoenorden(root.right);

public void nodosconhijos(trabajo1 root) {

if (root != null) {

if (root.left != null && root.right != null) {

nodosconhijos(root.left);

System.out.print(root.data + " ");

nodosconhijos(root.right);

} else {

nodosconhijos(root.left);

nodosconhijos(root.right);

}
 public void nodosconunhijopar(trabajo1 root) {

if (root != null) {

if ((root.left != null && root.left.data % 2 ==

0) || (root.right != null && root.right.data % 2 == 0))

System.out.print(root.data + " ");

nodosconunhijopar(root.left);

nodosconunhijopar(root.right);

public int sumadehijos(trabajo1 root) {

if (root == null) {

return 0;

int sum = 0;

if (root.left != null) {
 sum += root.left.data;

if (root.right != null) {

sum += root.right.data;

return sum;

public void mostrarsumadehijos(trabajo1 root) {

if (root != null) {

System.out.print(sumadehijos(root) + " ");

mostrarsumadehijos(root.left);

mostrarsumadehijos(root.right);

public trabajo1 buscarnodo(trabajo1 root, int value)

{
 if (root == null || root.data == value) {

return root;

if (value < root.data) {

return buscarnodo(root.left, value);

} else {

return buscarnodo(root.right, value);

public void rutadelnodobuscado(trabajo1 root, int

value) {

trabajo1 node = buscarnodo(root, value);

if (node == null) {

System.out.println("El nodo no existe.");

} else {

System.out.print("El camino para llegar al

nodo " + value + " es: ");

 mostrarrutadelnodo(root, value);

System.out.println();

private boolean mostrarrutadelnodo(trabajo1 root,

int value) {

if (root == null) {

return false;

if (root.data == value ||

mostrarrutadelnodo(root.left, value) ||

mostrarrutadelnodo(root.right, value)) {

System.out.print(root.data + " ");

return true;

return false;
 }

En el archivo Main tenemos este otro código:

package trabajo1;

import java.util.Scanner;

public class Main {

public static void main(String[] args) {

BTS tree = new BTS();

Scanner scanner = new

Scanner(System.in);

System.out.print("Ingrese el número de

nodos que desea insertar: ");

int n = scanner.nextInt();

System.out.println("Ingrese los valores

de los nodos separados por espacios:");

 for (int i = 0; i < n; i++) {

int data = scanner.nextInt();

tree.insertar(data);

System.out.print("Ingrese el nodo a

buscar: ");

int nodeToFind = scanner.nextInt();

System.out.println("Árbol en orden:");

tree.recorridoenorden(tree.root);

System.out.println();

System.out.println("Nodos con dos

hijos:");

tree.nodosconhijos(tree.root);

System.out.println();
 System.out.println("Cantidad de nodos

con al menos un hijo par (en preorden):");

tree.nodosconunhijopar(tree.root);

System.out.println();

System.out.println("Suma de los hijos

de cada nodo (en preorden):");

tree.mostrarsumadehijos(tree.root);

System.out.println();

System.out.println("Camino para llegar

al nodo " + nodeToFind + ":");

tree.rutadelnodobuscado(tree.root,

nodeToFind);

}
 Y por último tenemos el archivo Node que tiene el siguiente código:

package trabajo1;

class trabajo1 {
int data;
trabajo1 left;
trabajo1 right;

public trabajo1(int data) {

this.data = data;
left = null;
right = null;
}
}
 Conclusiones

El ejercicio 1 ofrece una forma eficiente de manipular datos en una estructura de datos
utilizando un arbol binario, además de proporcionar información sobre su
comportamiento y ejecución sobre los elementos almacenados.