diff --git a/.idea/uiDesigner.xml b/.idea/uiDesigner.xml
new file mode 100644
index 0000000..2b63946
--- /dev/null
+++ b/.idea/uiDesigner.xml
@@ -0,0 +1,124 @@
+
+
+
+
+ -
+
+
+ -
+
+
+ -
+
+
+ -
+
+
+ -
+
+
+
+
+
+ -
+
+
+
+
+
+ -
+
+
+
+
+
+ -
+
+
+
+
+
+ -
+
+
+
+
+ -
+
+
+
+
+ -
+
+
+
+
+ -
+
+
+
+
+ -
+
+
+
+
+ -
+
+
+
+
+ -
+
+
+ -
+
+
+
+
+ -
+
+
+
+
+ -
+
+
+
+
+ -
+
+
+
+
+ -
+
+
+
+
+ -
+
+
+ -
+
+
+ -
+
+
+ -
+
+
+ -
+
+
+
+
+ -
+
+
+ -
+
+
+
+
+
\ No newline at end of file
diff --git a/.idea/workspace.xml b/.idea/workspace.xml
index 2f81ed8..467a147 100644
--- a/.idea/workspace.xml
+++ b/.idea/workspace.xml
@@ -38,6 +38,7 @@
"keyToString": {
"RunOnceActivity.OpenProjectViewOnStart": "true",
"RunOnceActivity.ShowReadmeOnStart": "true",
+ "SHARE_PROJECT_CONFIGURATION_FILES": "true",
"WebServerToolWindowFactoryState": "false",
"git-widget-placeholder": "lists-implementation",
"ignore.virus.scanning.warn.message": "true",
@@ -86,6 +87,9 @@
+
+
+
diff --git a/README.md b/README.md
index b2ba9d7..d7592e6 100644
--- a/README.md
+++ b/README.md
@@ -1,6 +1,6 @@
# DataStructuresUNAL
-## Práctica 2
+## Práctica 3
### Integrantes:
@@ -9,46 +9,3 @@
### Instrucciones:
-
-1. Los empleados de la empresa se encuentran almacenados en un archivo de texto denominado
-“Empleados.txt”; en este archivo, se almacena la información personal (nombre, cedula, fecha de
-nacimiento, ciudad de nacimiento) y de contacto (teléfono, correo electrónico y dirección (calle,
-nomenclatura, barrio, ciudad, urbanización, número de apartamento)). Al iniciar el sistema debe cargar
-los empleados de la empresa desde el archivo de texto (ver archivo empleados.txt de ejemplo).
-2. Para acceder al sistema, cada empleado tiene una contraseña, conformada por número y letras. Las
-contraseñas de cada usuario se almacenan en un archivo de texto “Password.txt”. Este archivo incluye en
-cada línea: la cedula de ciudadanía de un usuario, su contraseña, y una descripción si el usuario es
-“empleado” o “administrador”. Para acceder al sistema, el usuario debe digitar su número de
-identificación y contraseña, y el sistema debe verificar con la información de este archivo si los datos son
-correctos (ver archivo Password.txt de ejemplo).
-3. El “administrador” del sistema tiene la posibilidad de realizar las mismas funcionalidades que los
-empleados, pero además puede, registrar nuevos usuarios al sistema, cambiar contraseñas, y eliminar
-usuarios. Cuando se realicen este tipo de cambios en la información de los usuarios, se debe actualizar el
-archivo Empleados.txt y Password.txt, manteniendo la consistencia entre ambos.
-4. El “empleado” puede revisar su bandeja de entrada, los mensajes leídos, proyectar mensaje que se
-mantienen en borradores, y enviar mensajes a usuarios del sistema.
-5. La bandeja de entrada de cada empleado mantiene la colección de mensajes electrónicos que aún no
-se han leído. Al consultar la bandeja de entrada por consola, esta debe presentar la fecha de recepción,
-el titulo del mensaje y el nombre de la persona que lo envió. Adicionalmente, debe permitir seleccionar
-cual mensaje se desea leer (tip: se recomienda implementar la bandeja de entrada como una lista
-doble).
-5. Una vez leído un mensaje electrónico se elimina de la “bandeja de entrada” y pasa a la carpeta de
-mensajes leídos. El empleado puede consultar los mensajes leídos de forma secuencial, iniciando desde
-el mas antiguo (tip: se recomienda implementar los mensajes leídos como una cola).
-6. Cuando un usuario quiere redactar un nuevo mensaje, por consola, se debe pedir:
-• Cedula del usuario al que se envía el mensaje
-• Título del mensaje
-• Mensaje
-Además de la información que redacta el usuario, cada mensaje de forma automática se le asigna la
-fecha y hora de envió. El empleado tiene las opciones de guardar como borrador, descartar o enviar el
-mensaje.
-7. Cuando un empleado decide almacenar como borrador un mensaje de texto, el sistema almacena el
-mensaje en una colección, donde el empleado solo puede acceder al último borrador (más reciente).
-Para acceder a otro mensaje, el empleado debe descartar el mensaje actual o enviarlo (tip: se
-recomienda que los borradores se almacenen en una pila).
-8. Cuando un empleado decide descartar el mensaje, este se elimina del sistema.
-9. Cuando un empleado envía un mensaje, el sistema lo agrega a la bandeja de entrada del destinatario
-correspondiente.
-10. Los mensajes en la bandeja de entrada, mensajes leídos, y borradores de cada usuario se almacena
-en archivos de texto, denominados por el número de cedula del empleado, seguido por las letras BA
-para la bandeja de entrada, ML para los mensajes leídos y B para los borradores.
diff --git a/demo/src/main/java/Tree/BSTEntry.java b/demo/src/main/java/Tree/BSTEntry.java
new file mode 100644
index 0000000..5cf1294
--- /dev/null
+++ b/demo/src/main/java/Tree/BSTEntry.java
@@ -0,0 +1,53 @@
+package Tree;
+
+public class BSTEntry {
+ // Atributos de un nodo de un arbol binario de busqueda
+ private Object data;
+ private int k;
+ private BSTEntry left;
+ private BSTEntry right;
+
+
+ // Constructores
+
+ public BSTEntry(Object e, int k) {
+ this.data = e;
+ this.k = k;
+ }
+
+ // Getters and setters
+ public Object getData() {
+ return data;
+ }
+
+ public int getKey() {
+ return k;
+ }
+ public BSTEntry getLeft() {
+ return left;
+ }
+
+ public BSTEntry getRight() {
+ return right;
+ }
+ public void setData(Object data) {
+ this.data = data;
+ }
+
+ public void setKey(int k) {
+ this.k = k;
+ }
+
+ public void setLeft(BSTEntry left) {
+ this.left = left;
+ }
+
+ public void setRight(BSTEntry right) {
+ this.right = right;
+ }
+
+ @Override
+ public String toString() {
+ return "{ Key= " + k + " , Data= " + data +" } ";
+ }
+}
\ No newline at end of file
diff --git a/demo/src/main/java/Tree/BinaryNode.java b/demo/src/main/java/Tree/BinaryNode.java
new file mode 100644
index 0000000..6fd4a62
--- /dev/null
+++ b/demo/src/main/java/Tree/BinaryNode.java
@@ -0,0 +1,47 @@
+package Tree;
+
+
+public class BinaryNode {
+ //Implementación de un nodo para árbol binario
+ private Object data;
+ private BinaryNode left;
+ private BinaryNode right;
+
+ //Constructors
+ public BinaryNode() {
+ this.data = null;
+
+ }
+
+ public BinaryNode(Object data) {
+ this.data = data;
+ this.left = null;
+ this.right = null;
+ }
+
+ //Getters de la clase
+ public Object getData() {
+ return data;
+ }
+
+ public BinaryNode getLeft() {
+ return left;
+ }
+
+ public BinaryNode getRight() {
+ return right;
+ }
+
+ //Setters de la clase
+ public void setData(Object data) {
+ this.data = data;
+ }
+
+ public void setLeft(BinaryNode left) {
+ this.left = left;
+ }
+
+ public void setRight(BinaryNode right) {
+ this.right = right;
+ }
+}
diff --git a/demo/src/main/java/Tree/BinarySearchTree.java b/demo/src/main/java/Tree/BinarySearchTree.java
new file mode 100644
index 0000000..12f68f4
--- /dev/null
+++ b/demo/src/main/java/Tree/BinarySearchTree.java
@@ -0,0 +1,176 @@
+package Tree;
+
+public class BinarySearchTree extends BinaryTree {
+
+ public BinarySearchTree() {
+ super();
+ }
+
+ // Metodos
+ public BinaryNode find(int k) {
+ return searchTree(k, root);
+ }
+
+ public BinaryNode searchTree(int k, BinaryNode v) {
+ if (v == null) {
+ return null;
+ }
+ BSTEntry u = (BSTEntry) v.getData();
+ if (k == u.getKey()) { //Caso base
+ return v;
+ } else if (k < u.getKey()) {
+ return searchTree(k, v.getLeft());
+ } else {
+ return searchTree(k, v.getRight());
+ }
+ }
+
+
+ //
+ public void insert(Object e, int k) {
+ BSTEntry O = new BSTEntry(e, k);
+ if (isEmpty()) {
+ super.addRoot(O);
+ } else {
+ addEntry(root, O);
+ }
+ }
+
+ public void addEntry(BinaryNode v, BSTEntry o) {
+ BSTEntry temp = (BSTEntry) v.getData();
+ BinaryNode nD = new BinaryNode(o);
+ if (o.getKey() < temp.getKey()) {
+ if (hasLeft(v)) {
+ addEntry(v.getLeft(), o);
+ } else {
+ v.setLeft(nD);
+ }
+ } else {
+ if (hasRight(v)) {
+ addEntry(v.getRight(), o);
+ } else {
+ v.setRight(nD);
+ }
+ }
+ }
+
+ public BSTEntry deleteNode(int k) {
+ return deleteRecursive((BSTEntry) root.getData(), k);
+ }
+
+ public BSTEntry deleteRecursive(BSTEntry v, int k) {
+ if (v == null) {
+ return null;
+ }
+ BSTEntry temp = v;
+ //Realizamos la busqueda del nodo a eliminar
+ if (k < temp.getKey()) {
+ v.setLeft(deleteRecursive(v.getLeft(), k));
+ } else if (k > temp.getKey()) {
+ v.setRight(deleteRecursive(v.getRight(), k));
+ } else {
+ if (v.getLeft() == null) {
+ return (BSTEntry) v.getRight().getData();
+ } else if (v.getRight() == null) {
+ return (BSTEntry) v.getLeft().getData();
+ }
+ v.setData(minValue(v.getRight()));
+ v.setRight(deleteRecursive(v.getRight(), temp.getKey()));
+ }
+ return temp;
+ }
+
+ private int minValue(BSTEntry root) {
+ int minValue = root.getLeft().getKey();
+ while (root.getLeft() != null) {
+ minValue = root.getLeft().getKey();
+ root = root.getLeft();
+ }
+ return minValue;
+ }
+
+ /*public Object Remove(int k) {
+ BinaryNode v = find(k);
+ Object temp = v.getData();
+ if (hasLeft(v) && hasRight(v)) { //caso 2
+ BinaryNode w = predecessor(v);
+ v.setData(w.getData());
+ super.remove(w);
+ } else { //caso 1
+ super.remove(v);
+ }
+ return temp;
+ }*/
+
+ public BinaryNode predecessor(BinaryNode v) {
+ BinaryNode temp = v.getLeft();
+ return maxNode(temp);
+ }
+
+ public BinaryNode maxNode(BinaryNode temp) {
+ if (hasRight(temp)) {
+ return maxNode(temp.getRight());
+ } else {
+ return temp;
+ }
+ }
+
+ public BinaryNode successor(BinaryNode v) {
+ BinaryNode temp = v.getRight();
+ return minNode(temp);
+ }
+
+ public BinaryNode minNode(BinaryNode temp) {
+ if (hasLeft(temp)) {
+ return minNode(temp.getLeft());
+ } else {
+ return temp;
+ }
+ }
+
+ public Object getMinKeyObject() {
+ if (isEmpty()) {
+ return null; // Return null if the tree is empty
+ }
+
+ BinaryNode minNode = minNode(root);
+ BSTEntry minEntry = (BSTEntry) minNode.getData();
+ return minEntry.getData();
+ }
+
+
+ public Object getMaxKeyObject() {
+ if (isEmpty()) {
+ return null; // Return null if the tree is empty
+ }
+
+ BinaryNode maxNode = maxNode(root);
+ BSTEntry maxEntry = (BSTEntry) maxNode.getData();
+ return maxEntry.getData();
+ }
+
+ public void inOrder(BSTEntry node) {
+ if (node != null) {
+ inOrder(node.getLeft());
+ BSTEntry temp = (BSTEntry) node.getData();
+ System.out.print(Integer.toString(temp.getKey()) + " ");
+ inOrder(node.getRight());
+ }
+ }
+ public void inOrderShow(BinaryNode node, int level) {
+ if (node != null) {
+ inOrderShow(node.getRight(), level + 1);
+ printTree(node, level);
+ inOrderShow(node.getLeft(), level + 1);
+ }
+ }
+
+ public void printTree(BinaryNode node, int level) {
+ for (int i = 0; i < level; i++) {
+ System.out.print(" ");
+ }
+ System.out.println(node.getData());
+
+ }
+
+}
diff --git a/demo/src/main/java/Tree/BinaryTree.java b/demo/src/main/java/Tree/BinaryTree.java
new file mode 100644
index 0000000..c02933d
--- /dev/null
+++ b/demo/src/main/java/Tree/BinaryTree.java
@@ -0,0 +1,197 @@
+package Tree;
+import Queue.Queue;
+
+public class BinaryTree {
+ //Atributos de la clase
+ public BinaryNode root; //Raíz del árbol
+ private int size; //Tamaño del árbol
+
+ //Constructores
+ public BinaryTree() {
+ this.root = null;
+ this.size = 0;
+ }
+
+ //Verificación de atributos
+ public boolean isEmpty() {
+ return size == 0;
+ }
+
+ public boolean isRoot(BinaryNode node) {
+ return node == root;
+ }
+
+ //Verificación de hijos
+ public boolean hasLeft(BinaryNode node) {
+ return node.getLeft() != null;
+ }
+
+ public boolean hasRight(BinaryNode node) {
+ return node.getRight() != null;
+ }
+
+ //Verifica si un nodo es interno
+ public boolean isInternal(BinaryNode node) {
+ return hasLeft(node) || hasRight(node);
+ }
+
+
+ //Getters de la clase
+ public int getSize() {
+ return size;
+ }
+
+ public BinaryNode getRoot() {
+ return root;
+ }
+
+
+ //Retorno de hijos de un nodo
+ public BinaryNode left(BinaryNode node) {
+ return node.getLeft();
+ }
+
+ public BinaryNode right(BinaryNode node) {
+ return node.getRight();
+ }
+
+ //Retorno del padre de un nodo
+ public BinaryNode parent(BinaryNode node) {
+ if (isRoot(node)) {
+ return null;
+ } else {
+ Queue queue = new Queue();
+ queue.enqueue(root);
+ BinaryNode temp = root;
+
+ while (!queue.isEmpty() && left((BinaryNode) queue.first())!= node && right((BinaryNode) queue.first()) != node) {
+ temp = (BinaryNode) queue.dequeue();
+ if (hasLeft(temp)) {
+ queue.enqueue(left(temp));
+ }
+ if (hasRight(temp)) {
+ queue.enqueue(right(temp));
+ }
+ return temp;
+ }
+
+ }
+ return node;
+ }
+
+ //Retorno de la profundidad de un nodo
+ public int depth(BinaryNode node) {
+ if (isRoot(node)) {
+ return 0;
+ } else {
+ return 1 + depth(parent(node));
+ }
+ }
+
+ //Retorno de la altura de un nodo
+ public int height(BinaryNode node) {
+ if (!isInternal(node)) {
+ return 0;
+ } else {
+ int h = 0;
+ if (hasLeft(node)) {
+ h = Math.max(h, height(left(node)));
+ }
+ if (hasRight(node)) {
+ h = Math.max(h, height(right(node)));
+ }
+ return 1 + h;
+ }
+ }
+
+ //Agregar una raíz
+ public void addRoot(Object element) {
+ root = new BinaryNode(element);
+ size = 1;
+ }
+
+ //Agregar hijos
+ public void addLeft(BinaryNode node, Object element) {
+ BinaryNode newNode = new BinaryNode(element);
+ node.setLeft(newNode);
+ size++;
+ }
+
+ public void addRight(BinaryNode node, Object element) {
+ BinaryNode newNode = new BinaryNode(element);
+ node.setRight(newNode);
+ size++;
+ }
+
+ //Remover un nodo
+ public BinaryNode remove(BinaryNode node){
+ BinaryNode parent = parent(node);
+ if (hasLeft(node) && hasRight(node)) {
+ if (parent.getLeft() == node) {
+ parent.setLeft(null);
+ } else {
+ parent.setRight(null);
+ }
+ return node;
+ } else if (hasLeft(node) || hasRight(node)){
+ if (hasLeft(node)) {
+ if (parent.getLeft() == node) {
+ parent.setLeft(left(node));
+ } else {
+ parent.setRight(left(node));
+ }
+ } else if (hasRight(node)){
+ if (parent.getLeft() == node) {
+ parent.setLeft(right(node));
+ } else {
+ parent.setRight(right(node));
+ }
+ }
+ return node;
+ } else {
+ if (parent.getLeft() == node) {
+ parent.setLeft(null);
+ } else {
+ parent.setRight(null);
+ }
+ return node;
+ }
+ }
+
+ //Recorridos de los árboles
+ public void preOrder(BinaryNode node) {
+ if (node != null) {
+ System.out.println(node.getData());
+ if (hasLeft(node)) {
+ preOrder(left(node));
+ }
+ if (hasRight(node)) {
+ preOrder(right(node));
+ }
+ }
+ }
+
+ public void inOrder(BinaryNode node) {
+ if (node != null) {
+ if (hasLeft(node)) {
+ inOrder(left(node));
+ }
+ System.out.println(node.getData());
+ if (hasRight(node)) {
+ inOrder(right(node));
+ }
+ }
+ }
+
+ public void postOrder(BinaryNode node) {
+ if (node != null) {
+ if (hasLeft(node)) {
+ postOrder(left(node));
+ }
+ if (hasRight(node)) {
+ postOrder(right(node));
+ }
+ System.out.println(node.getData());
+ }
+ }
+}
diff --git a/demo/src/main/java/com/example/BandejaEntrada.java b/demo/src/main/java/com/example/Clases varias/BandejaEntrada.java
similarity index 100%
rename from demo/src/main/java/com/example/BandejaEntrada.java
rename to demo/src/main/java/com/example/Clases varias/BandejaEntrada.java
diff --git a/demo/src/main/java/com/example/Borradores.java b/demo/src/main/java/com/example/Clases varias/Borradores.java
similarity index 100%
rename from demo/src/main/java/com/example/Borradores.java
rename to demo/src/main/java/com/example/Clases varias/Borradores.java
diff --git a/demo/src/main/java/com/example/Credenciales.java b/demo/src/main/java/com/example/Clases varias/Credenciales.java
similarity index 100%
rename from demo/src/main/java/com/example/Credenciales.java
rename to demo/src/main/java/com/example/Clases varias/Credenciales.java
diff --git a/demo/src/main/java/com/example/Direccion.java b/demo/src/main/java/com/example/Clases varias/Direccion.java
similarity index 100%
rename from demo/src/main/java/com/example/Direccion.java
rename to demo/src/main/java/com/example/Clases varias/Direccion.java
diff --git a/demo/src/main/java/com/example/Fecha.java b/demo/src/main/java/com/example/Clases varias/Fecha.java
similarity index 100%
rename from demo/src/main/java/com/example/Fecha.java
rename to demo/src/main/java/com/example/Clases varias/Fecha.java
diff --git a/demo/src/main/java/com/example/Mensaje.java b/demo/src/main/java/com/example/Clases varias/Mensaje.java
similarity index 100%
rename from demo/src/main/java/com/example/Mensaje.java
rename to demo/src/main/java/com/example/Clases varias/Mensaje.java
diff --git a/demo/src/main/java/com/example/MensajesLeidos.java b/demo/src/main/java/com/example/Clases varias/MensajesLeidos.java
similarity index 100%
rename from demo/src/main/java/com/example/MensajesLeidos.java
rename to demo/src/main/java/com/example/Clases varias/MensajesLeidos.java
diff --git a/demo/src/main/java/com/example/Menu.java b/demo/src/main/java/com/example/Clases varias/Menu.java
similarity index 99%
rename from demo/src/main/java/com/example/Menu.java
rename to demo/src/main/java/com/example/Clases varias/Menu.java
index 0a21285..1262eb9 100644
--- a/demo/src/main/java/com/example/Menu.java
+++ b/demo/src/main/java/com/example/Clases varias/Menu.java
@@ -1,6 +1,5 @@
package com.example;
-import java.io.IOException;
import java.util.Scanner;
public class Menu {
diff --git a/demo/src/main/java/com/example/Registro.java b/demo/src/main/java/com/example/Clases varias/Registro.java
similarity index 100%
rename from demo/src/main/java/com/example/Registro.java
rename to demo/src/main/java/com/example/Clases varias/Registro.java
diff --git a/demo/src/main/java/com/example/RegistroCredenciales.java b/demo/src/main/java/com/example/Clases varias/RegistroCredenciales.java
similarity index 100%
rename from demo/src/main/java/com/example/RegistroCredenciales.java
rename to demo/src/main/java/com/example/Clases varias/RegistroCredenciales.java
diff --git a/demo/src/main/java/com/example/Usuario.java b/demo/src/main/java/com/example/Clases varias/Usuario.java
similarity index 100%
rename from demo/src/main/java/com/example/Usuario.java
rename to demo/src/main/java/com/example/Clases varias/Usuario.java
diff --git a/demo/src/main/java/com/example/Main.java b/demo/src/main/java/com/example/Main.java
index 94ead66..eadddde 100644
--- a/demo/src/main/java/com/example/Main.java
+++ b/demo/src/main/java/com/example/Main.java
@@ -1,18 +1,11 @@
package com.example;
-import java.time.LocalDateTime;
+import Tree.*;
public class Main {
public static void main(String[] args) {
- // LocalDateTime fecha = LocalDateTime.now();
- // System.out.println(fecha);
- // String fechaString = fecha.toString();
+ TreeMenu menu = new TreeMenu();
+ menu.TreeMenu();
- //Veamos como parsear la fecha
- //LocalDateTime fechaParseada = LocalDateTime.parse(fechaString);
- // System.out.println(fechaParseada);
-
- Menu menu = new Menu();
- menu.menuIngreso();
}
}
\ No newline at end of file
diff --git a/demo/src/main/java/com/example/TreeMenu.java b/demo/src/main/java/com/example/TreeMenu.java
new file mode 100644
index 0000000..6fc5d6a
--- /dev/null
+++ b/demo/src/main/java/com/example/TreeMenu.java
@@ -0,0 +1,91 @@
+package com.example;
+
+import Tree.BinaryNode;
+import Tree.BinarySearchTree;
+
+import java.util.Scanner;
+
+public class TreeMenu {
+ public void TreeMenu(){
+ Scanner sc = new Scanner(System.in);
+ int opcion = 0;
+ BinarySearchTree bst = new BinarySearchTree();
+ do {
+ System.out.println("----------------------");
+ System.out.println("Bienvenido al sistema:");
+ System.out.println("1. Insertar Usuario");
+ System.out.println("2. Eliminar Usuario");
+ System.out.println("3. Buscar Usuario");
+ System.out.println("4. Valor máximo y mínimo");
+ System.out.println("5. Mostrar Arbol");
+ System.out.println("6. Recorrido Inorder");
+ System.out.println("7. Salir");
+ System.out.println("----------------------");
+ System.out.print("Ingrese el número de opción: ");
+ opcion = sc.nextInt();
+ sc.nextLine();
+ switch (opcion) {
+ case 1:
+ //Se guardan los atributos del usuario
+ System.out.println("Inserte el nombre del usuario: ");
+ String nombre = sc.nextLine();
+ System.out.println("----------------------");
+ System.out.println("Inserte la ID del usuario: ");
+ int id = sc.nextInt();
+ System.out.println("----------------------");
+
+ User user = new User(nombre, id);
+
+ bst.insert(user, user.SumaDigitos());
+ break;
+ case 2:
+ System.out.println("Inserte la key del usuario que desea eliminar: ");
+ int key = sc.nextInt();
+ Object removedObject = bst.deleteNode(key);
+ if (removedObject != null) {
+ System.out.println("Objeto eliminado: " + removedObject);
+ } else {
+ System.out.println("No se encontró el nodo con la key especificada.");
+ }
+ break;
+ case 3:
+ System.out.println("Inserte la key del usuario que desea buscar: ");
+ key = sc.nextInt();
+ BinaryNode foundNode = bst.find(key);
+ if (foundNode != null) {
+ System.out.println("Usuario encontrado: ");
+ System.out.println(foundNode.getData().toString());
+ } else {
+ System.out.println("El usuario no se encuentra en el árbol.");
+ }
+ break;
+ case 4:
+ System.out.println("El usuario con key más grande es: " + bst.getMaxKeyObject());
+ System.out.println("El usuario con key más pequeña es: " + bst.getMinKeyObject());
+ break;
+ case 5:
+ System.out.println("Mostrar árbol");
+ bst.inOrderShow(bst.getRoot(), 0);
+ break;
+ case 6:
+ System.out.println("Resultado del inorder");
+ if (bst.isEmpty()) {
+ System.out.println("No hay usuarios en el arbol");
+ } else {
+ System.out.println("Claves InOrder: ");
+ bst.inOrder(bst.getRoot()); // Pass bst.root as an argument
+ System.out.println();
+ }
+ break;
+ case 7:
+ System.out.println("Gracias por usar el sistema!");
+ break;
+ default:
+ System.out.println("Opción no válida!");
+ break;
+ }
+ } while (opcion != 7);
+ sc.close();
+ }
+
+ }
diff --git a/demo/src/main/java/com/example/User.java b/demo/src/main/java/com/example/User.java
new file mode 100644
index 0000000..0e76bb7
--- /dev/null
+++ b/demo/src/main/java/com/example/User.java
@@ -0,0 +1,57 @@
+package com.example;
+
+
+public class User {
+ //Atributos de la clase
+ private String Nombre;
+ private int ID;
+
+ //Constructores
+
+ public User() {
+ this.Nombre = null;
+ this.ID = 0;
+ }
+
+ public User(String Nombre, int ID) {
+ this.Nombre = Nombre;
+ this.ID = ID;
+ }
+
+ //Getters de la clase
+
+ public String getNombre() {
+ return Nombre;
+ }
+
+ public int getID() {
+ return ID;
+ }
+
+ //Setters de la clase
+
+ public void setNombre(String Nombre) {
+ this.Nombre = Nombre;
+ }
+
+ public void setID(int ID) {
+ this.ID = ID;
+ }
+
+ //Metodo para sumar los digitos de la ID
+
+ public int SumaDigitos() {
+ int suma = 0;
+ int aux = this.ID;
+ while (aux > 0) {
+ suma += aux % 10;
+ aux /= 10;
+ }
+ return suma;
+ }
+
+ //Metodo toString
+ public String toString() {
+ return "Nombre: " + this.Nombre + " | ID: " + this.ID + "|- KEY -" + this.SumaDigitos() + "\n";
+ }
+}
\ No newline at end of file
diff --git a/demo/target/classes/Tree/BSTEntry.class b/demo/target/classes/Tree/BSTEntry.class
new file mode 100644
index 0000000..f650026
Binary files /dev/null and b/demo/target/classes/Tree/BSTEntry.class differ
diff --git a/demo/target/classes/Tree/BinaryNode.class b/demo/target/classes/Tree/BinaryNode.class
new file mode 100644
index 0000000..9c64ffb
Binary files /dev/null and b/demo/target/classes/Tree/BinaryNode.class differ
diff --git a/demo/target/classes/Tree/BinarySearchTree.class b/demo/target/classes/Tree/BinarySearchTree.class
new file mode 100644
index 0000000..a94ed7d
Binary files /dev/null and b/demo/target/classes/Tree/BinarySearchTree.class differ
diff --git a/demo/target/classes/Tree/BinaryTree.class b/demo/target/classes/Tree/BinaryTree.class
new file mode 100644
index 0000000..71c0db8
Binary files /dev/null and b/demo/target/classes/Tree/BinaryTree.class differ
diff --git a/demo/target/classes/com/example/BandejaEntrada.class b/demo/target/classes/com/example/BandejaEntrada.class
index 7ba9466..4671941 100644
Binary files a/demo/target/classes/com/example/BandejaEntrada.class and b/demo/target/classes/com/example/BandejaEntrada.class differ
diff --git a/demo/target/classes/com/example/Borradores.class b/demo/target/classes/com/example/Borradores.class
index e7149b5..83892a0 100644
Binary files a/demo/target/classes/com/example/Borradores.class and b/demo/target/classes/com/example/Borradores.class differ
diff --git a/demo/target/classes/com/example/Datos/InfoUsuarios/Empleados.txt b/demo/target/classes/com/example/Datos/InfoUsuarios/Empleados.txt
deleted file mode 100644
index 8d76270..0000000
--- a/demo/target/classes/com/example/Datos/InfoUsuarios/Empleados.txt
+++ /dev/null
@@ -1,5 +0,0 @@
-Juan-Perez 24567898 12 10 1980 Medellin 3003233234 juanperez@edl.edu.co kr74 4T-35 Boston Medellin null null
-Diego-Palacio 34568910 20 12 1979 Envigado 3013234567 diegopalacio@edl.edu.co cll65 3-29 Robledo Medellin Balcones-de-la-Quinta 405
-Camila-Jimenez 2345902 15 09 1985 Cali 3003234567 camilajimenez@edl.edu.co tr45 4S-73 Poblado Medellin null null
-Pedro-Gomez 1075689 20 02 1990 Popayan 3003012323 pedrogomez@edl.edu.co kr23 8-10 SanJuan Envigado Mirador 503
-Tatiana-Ramirez 2345934 15 11 1982 Medellin 3004567890 tatianaramirez@edl.edu.co cll5 4S-69 Poblado Medellin UrbColina 1023
diff --git a/demo/target/classes/com/example/Datos/InfoUsuarios/Password.txt b/demo/target/classes/com/example/Datos/InfoUsuarios/Password.txt
deleted file mode 100644
index a9d851c..0000000
--- a/demo/target/classes/com/example/Datos/InfoUsuarios/Password.txt
+++ /dev/null
@@ -1,5 +0,0 @@
-24567898 j4an1980$ empleado
-34568910 d13go1979.* empleado
-2345902 c4100l485Cal$ administrador
-1075689 p3dr41990.$ empleado
-2345934 r482novMed. empleado
diff --git a/demo/target/classes/com/example/Direccion.class b/demo/target/classes/com/example/Direccion.class
index 35eb351..7acdc0b 100644
Binary files a/demo/target/classes/com/example/Direccion.class and b/demo/target/classes/com/example/Direccion.class differ
diff --git a/demo/target/classes/com/example/Main.class b/demo/target/classes/com/example/Main.class
index d2f1dc5..07cf9e8 100644
Binary files a/demo/target/classes/com/example/Main.class and b/demo/target/classes/com/example/Main.class differ
diff --git a/demo/target/classes/com/example/Mensaje.class b/demo/target/classes/com/example/Mensaje.class
index 11d63c4..05ef421 100644
Binary files a/demo/target/classes/com/example/Mensaje.class and b/demo/target/classes/com/example/Mensaje.class differ
diff --git a/demo/target/classes/com/example/MensajesLeidos.class b/demo/target/classes/com/example/MensajesLeidos.class
index fb54fd5..15551d2 100644
Binary files a/demo/target/classes/com/example/MensajesLeidos.class and b/demo/target/classes/com/example/MensajesLeidos.class differ
diff --git a/demo/target/classes/com/example/Menu.class b/demo/target/classes/com/example/Menu.class
index f4e539e..6528b51 100644
Binary files a/demo/target/classes/com/example/Menu.class and b/demo/target/classes/com/example/Menu.class differ
diff --git a/demo/target/classes/com/example/RegistroCredenciales.class b/demo/target/classes/com/example/RegistroCredenciales.class
index f3e8160..f0caef9 100644
Binary files a/demo/target/classes/com/example/RegistroCredenciales.class and b/demo/target/classes/com/example/RegistroCredenciales.class differ
diff --git a/demo/target/classes/com/example/TreeMenu.class b/demo/target/classes/com/example/TreeMenu.class
new file mode 100644
index 0000000..71df970
Binary files /dev/null and b/demo/target/classes/com/example/TreeMenu.class differ
diff --git a/demo/target/classes/com/example/User.class b/demo/target/classes/com/example/User.class
new file mode 100644
index 0000000..8713e16
Binary files /dev/null and b/demo/target/classes/com/example/User.class differ
diff --git a/demo/target/classes/com/example/Usuario.class b/demo/target/classes/com/example/Usuario.class
index ac32b2d..64b106e 100644
Binary files a/demo/target/classes/com/example/Usuario.class and b/demo/target/classes/com/example/Usuario.class differ