import [Link].

*;

public class SimuladorEstructuras {

static Scanner sc = new Scanner([Link]);

static int[] arreglo = new int[10];

static int arregloSize = 0;

static int[][] matriz = new int[3][3];

static Stack<Integer> pila = new Stack<>();

static Queue<Integer> cola = new LinkedList<>();

static ArrayList<Integer> lista = new ArrayList<>();

static class Nodo {

int dato;
Nodo izq;
Nodo der;
Nodo(int d) { dato = d; }
}

static Nodo raiz = null;

public static void main(String[] args) {

int opcion;
do {
[Link]("\n===== SIMULADOR DE ESTRUCTURAS DE DATOS =====");
[Link]("1. Arreglo");
[Link]("2. Matriz");
[Link]("3. Pila");
[Link]("4. Cola");
[Link]("5. ArrayList");
[Link]("6. Arbol binario");
[Link]("7. Salir");
[Link]("Elige una opcion: ");
opcion = leerEntero();

switch (opcion) {
case 1:
menuArreglo();
break;
case 2:
menuMatriz();
break;
case 3:
menuPila();
break;
case 4:
menuCola();
break;
case 5:
menuArrayList();
break;
case 6:
menuArbol();
break;
 case 7:
[Link]("Saliendo del simulador...");
break;
default:
[Link]("Opcion invalida.");
}
} while (opcion != 7);

[Link]("\nEstado final de las estructuras:");

mostrarArreglo();
mostrarMatriz();
mostrarPila();
mostrarCola();
mostrarArrayList();
[Link]("Arbol (inorden): ");
inorden(raiz);
[Link]();
}

static int leerEntero() {

while (true) {
try {
String linea = [Link]();
return [Link]([Link]());
} catch (Exception e) {
[Link]("Ingresa un numero entero: ");
}
}
}

static void menuArreglo() {

int op;
do {
[Link]("\n--- ARREGLO (int, tamaño 10) ---");
[Link]("1. Insertar valor");
[Link]("2. Modificar posicion");
[Link]("3. Mostrar arreglo");
[Link]("4. Volver");
[Link]("Opcion: ");
op = leerEntero();

switch (op) {
case 1:
if (arregloSize >= [Link]) {
[Link]("El arreglo esta lleno.");
} else {
[Link]("Valor a insertar: ");
int v = leerEntero();
arreglo[arregloSize] = v;
arregloSize++;
}
break;
case 2:
[Link]("Posicion a modificar (0-" + ([Link] -
1) + "): ");
int pos = leerEntero();
if (pos < 0 || pos >= [Link]) {
[Link]("Posicion fuera de rango.");
} else {
 [Link]("Nuevo valor: ");
int nv = leerEntero();
arreglo[pos] = nv;
}
break;
case 3:
mostrarArreglo();
break;
case 4:
break;
default:
[Link]("Opcion invalida.");
}
} while (op != 4);
}

static void mostrarArreglo() {

[Link]("\nArreglo:");
for (int i = 0; i < [Link]; i++) {
[Link]("[" + i + "]=" + arreglo[i] + " ");
}
[Link]();
}

static void menuMatriz() {

int op;
do {
[Link]("\n--- MATRIZ 3x3 (int) ---");
[Link]("1. Llenar matriz");
[Link]("2. Modificar celda");
[Link]("3. Mostrar matriz");
[Link]("4. Volver");
[Link]("Opcion: ");
op = leerEntero();

switch (op) {
case 1:
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
[Link]("Valor [" + i + "][" + j + "]: ");
matriz[i][j] = leerEntero();
}
}
break;
case 2:
[Link]("Fila (0-2): ");
int f = leerEntero();
[Link]("Columna (0-2): ");
int c = leerEntero();
if (f < 0 || f > 2 || c < 0 || c > 2) {
[Link]("Posicion fuera de rango.");
} else {
[Link]("Nuevo valor: ");
matriz[f][c] = leerEntero();
}
break;
case 3:
mostrarMatriz();
break;
 case 4:
break;
default:
[Link]("Opcion invalida.");
}
} while (op != 4);
}

static void mostrarMatriz() {

[Link]("\nMatriz 3x3:");
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
[Link](matriz[i][j] + "\t");
}
[Link]();
}
}

static void menuPila() {

int op;
do {
[Link]("\n--- PILA (Stack<Integer>) ---");
[Link]("1. Push (apilar)");
[Link]("2. Pop (desapilar)");
[Link]("3. Ver tope");
[Link]("4. Mostrar pila");
[Link]("5. Volver");
[Link]("Opcion: ");
op = leerEntero();

switch (op) {
case 1:
[Link]("Valor a apilar: ");
int v = leerEntero();
[Link](v);
break;
case 2:
if ([Link]()) {
[Link]("La pila esta vacia.");
} else {
int x = [Link]();
[Link]("Se desapilo: " + x);
}
break;
case 3:
if ([Link]()) {
[Link]("La pila esta vacia.");
} else {
[Link]("Tope: " + [Link]());
}
break;
case 4:
mostrarPila();
break;
case 5:
break;
default:
[Link]("Opcion invalida.");
}
 } while (op != 5);
}

static void mostrarPila() {

[Link]("\nPila (de abajo hacia arriba):");
[Link](pila);
}

static void menuCola() {

int op;
do {
[Link]("\n--- COLA (Queue<Integer>) ---");
[Link]("1. Encolar");
[Link]("2. Desencolar");
[Link]("3. Ver frente");
[Link]("4. Mostrar cola");
[Link]("5. Volver");
[Link]("Opcion: ");
op = leerEntero();

switch (op) {
case 1:
[Link]("Valor a encolar: ");
int v = leerEntero();
[Link](v);
break;
case 2:
if ([Link]()) {
[Link]("La cola esta vacia.");
} else {
int x = [Link]();
[Link]("Se desencolo: " + x);
}
break;
case 3:
if ([Link]()) {
[Link]("La cola esta vacia.");
} else {
[Link]("Frente: " + [Link]());
}
break;
case 4:
mostrarCola();
break;
case 5:
break;
default:
[Link]("Opcion invalida.");
}
} while (op != 5);
}

static void mostrarCola() {

[Link]("\nCola (frente a final):");
[Link](cola);
}

static void menuArrayList() {

int op;
 do {
[Link]("\n--- ARRAYLIST (Integer) ---");
[Link]("1. Agregar elemento");
[Link]("2. Eliminar por indice");
[Link]("3. Mostrar lista");
[Link]("4. Volver");
[Link]("Opcion: ");
op = leerEntero();

switch (op) {
case 1:
[Link]("Valor a agregar: ");
int v = leerEntero();
[Link](v);
break;
case 2:
if ([Link]()) {
[Link]("La lista esta vacia.");
} else {
[Link]("Indice a eliminar (0-" + ([Link]() -
1) + "): ");
int idx = leerEntero();
if (idx < 0 || idx >= [Link]()) {
[Link]("Indice fuera de rango.");
} else {
int x = [Link](idx);
[Link]("Se elimino: " + x);
}
}
break;
case 3:
mostrarArrayList();
break;
case 4:
break;
default:
[Link]("Opcion invalida.");
}
} while (op != 4);
}

static void mostrarArrayList() {

[Link]("\nArrayList:");
[Link](lista);
}

static void menuArbol() {

int op;
do {
[Link]("\n--- ARBOL BINARIO DE BUSQUEDA ---");
[Link]("1. Insertar nodo");
[Link]("2. Mostrar inorden");
[Link]("3. Mostrar preorden");
[Link]("4. Mostrar postorden");
[Link]("5. Volver");
[Link]("Opcion: ");
op = leerEntero();

switch (op) {
 case 1:
[Link]("Valor a insertar: ");
int v = leerEntero();
raiz = insertarNodo(raiz, v);
break;
case 2:
[Link]("Inorden: ");
inorden(raiz);
[Link]();
break;
case 3:
[Link]("Preorden: ");
preorden(raiz);
[Link]();
break;
case 4:
[Link]("Postorden: ");
postorden(raiz);
[Link]();
break;
case 5:
break;
default:
[Link]("Opcion invalida.");
}
} while (op != 5);
}

static Nodo insertarNodo(Nodo r, int dato) {

if (r == null) {
return new Nodo(dato);
}
if (dato < [Link]) {
[Link] = insertarNodo([Link], dato);
} else if (dato > [Link]) {
[Link] = insertarNodo([Link], dato);
}
return r;
}

static void inorden(Nodo r) {

if (r != null) {
inorden([Link]);
[Link]([Link] + " ");
inorden([Link]);
}
}

static void preorden(Nodo r) {

if (r != null) {
[Link]([Link] + " ");
preorden([Link]);
preorden([Link]);
}
}

static void postorden(Nodo r) {

if (r != null) {
postorden([Link]);
 postorden([Link]);
[Link]([Link] + " ");
}
}
}