PRACTICA DE EXCEL INTERMEDIO

 EJERCICIO

C# : ARBOLES BINARIOS

ARBOLES BINARIOS

Los árboles binarios en C# son estructuras de datos jerárquicas donde cada nodo tiene, como máximo, dos hijos: izquierdo y derecho. Son fundamentales para organizar información de forma no secuencial y optimizar procesos de búsqueda y ordenamiento.

CODIGO:

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

 

namespace ConsoleApplication9

{

    using System;

 

    // Clase Nodo del árbol

    public class Nodo

    {

        public int valor;

        public Nodo izquierdo;

 

 

 

        public Nodo derecho;

 

        public Nodo(int valor)

        {

            this.valor = valor;

            izquierdo = null;

            derecho = null;

        }

    }

 

    // Clase principal del Árbol Binario de Búsqueda

    public class ArbolBinarioBusqueda

    {

        private Nodo raiz;

 

        public ArbolBinarioBusqueda()

        {

            raiz = null;

        }

 

        // Insertar un nuevo valor

        public void Insertar(int valor)

        {

            raiz = InsertarRec(raiz, valor);

        }

 

        private Nodo InsertarRec(Nodo raiz, int valor)

        {

            // Si el nodo está vacío, crear nuevo nodo

            if (raiz == null)

            {

                raiz = new Nodo(valor);

                return raiz;

            }

 

            // Ir a la izquierda si el valor es menor

            if (valor < raiz.valor)

                raiz.izquierdo = InsertarRec(raiz.izquierdo, valor);

            // Ir a la derecha si el valor es mayor

            else if (valor > raiz.valor)

                raiz.derecho = InsertarRec(raiz.derecho, valor);

 

            return raiz;

        }

 

        // Buscar un valor en el árbol

        public bool Buscar(int valor)

        {

            return BuscarRec(raiz, valor);

        }

 

        private bool BuscarRec(Nodo raiz, int valor)

        {

            // Árbol vacío o valor encontrado

            if (raiz == null || raiz.valor == valor)

                return raiz != null;

 

            // Buscar en subárbol izquierdo si valor es menor

            if (valor < raiz.valor)

                return BuscarRec(raiz.izquierdo, valor);

 

            // Buscar en subárbol derecho si valor es mayor

            return BuscarRec(raiz.derecho, valor);

        }

 

        // Eliminar un nodo

        public void Eliminar(int valor)

        {

            raiz = EliminarRec(raiz, valor);

        }

 

        private Nodo EliminarRec(Nodo raiz, int valor)

        {

            if (raiz == null) return raiz;

 

            if (valor < raiz.valor)

                raiz.izquierdo = EliminarRec(raiz.izquierdo, valor);

            else if (valor > raiz.valor)

                raiz.derecho = EliminarRec(raiz.derecho, valor);

            else

            {

                // Nodo con un solo hijo o sin hijos

                if (raiz.izquierdo == null)

                    return raiz.derecho;

                else if (raiz.derecho == null)

                    return raiz.izquierdo;

 

                // Nodo con dos hijos: obtener el inorder successor

                raiz.valor = MinimoValor(raiz.derecho);

 

                // Eliminar el inorder successor

                raiz.derecho = EliminarRec(raiz.derecho, raiz.valor);

            }

            return raiz;

        }

 

        private int MinimoValor(Nodo raiz)

        {

            int minimo = raiz.valor;

            while (raiz.izquierdo != null)

            {

                minimo = raiz.izquierdo.valor;

                raiz = raiz.izquierdo;

            }

            return minimo;

        }

 

        // Recorrido Inorden (izquierda-raíz-derecha)

        public void Inorden()

        {

            InordenRec(raiz);

            Console.WriteLine();

        }

 

        private void InordenRec(Nodo raiz)

        {

            if (raiz != null)

            {

                InordenRec(raiz.izquierdo);

                Console.Write(raiz.valor + " ");

                InordenRec(raiz.derecho);

            }

        }

 

        // Recorrido Preorden (raíz-izquierda-derecha)

        public void Preorden()

        {

            PreordenRec(raiz);

            Console.WriteLine();

        }

 

        private void PreordenRec(Nodo raiz)

        {

            if (raiz != null)  

            {

                Console.Write(raiz.valor + " ");

                PreordenRec(raiz.izquierdo);

                PreordenRec(raiz.derecho);

            }

        }

 

        // Recorrido Postorden (izquierda-derecha-raíz)

        public void Postorden()

        {

            PostordenRec(raiz);

            Console.WriteLine();

        }

 

        private void PostordenRec(Nodo raiz)

        {

            if (raiz != null)

            {

                PostordenRec(raiz.izquierdo);

                PostordenRec(raiz.derecho);

                Console.Write(raiz.valor + " ");

            }

        }

 

        // Altura del árbol

        public int Altura()

        {

            return AlturaRec(raiz);

        }

 

        private int AlturaRec(Nodo raiz)

        {

            if (raiz == null)

                return -1;

            return 1 + Math.Max(AlturaRec(raiz.izquierdo), AlturaRec(raiz.derecho));

        }

 

        // Verificar si el árbol está vacío

        public bool EstaVacio()

        {

            return raiz == null;

        }

    }

 

    // Programa principal para probar el árbol

    class Program

    {

        static void Main(string[] args)

        {

            ArbolBinarioBusqueda arbol = new ArbolBinarioBusqueda();

 

            // Insertar valores

            int[] valores = { 50, 30, 70, 20, 40, 60, 80 };

            Console.WriteLine("Insertando valores: ");

            foreach (int val in valores)

            {

                arbol.Insertar(val);

                Console.Write(val + " ");

            }

            Console.WriteLine("\n");

 

            // Recorridos

            Console.WriteLine("=== RECORRIDOS ===");

            Console.Write("Inorden:  "); arbol.Inorden();

            Console.Write("Preorden: "); arbol.Preorden();

            Console.Write("Postorden:"); arbol.Postorden();

 

            // Búsquedas

            Console.WriteLine("\n=== BÚSQUEDAS ===");

            Console.WriteLine("Buscar 40: " + (arbol.Buscar(40) ? "ENCONTRADO" : "NO ENCONTRADO"));

            Console.WriteLine("Buscar 90: " + (arbol.Buscar(90) ? "ENCONTRADO" : "NO ENCONTRADO"));

 

            // Altura

            Console.WriteLine("\nAltura del árbol: " + arbol.Altura());

 

            // Eliminar nodo

            Console.WriteLine("\nEliminando nodo 20...");

            arbol.Eliminar(20);

            Console.Write("Nuevo Inorden: "); arbol.Inorden();

            Console.ReadKey(); // Pausa para ver resultados;

        }

      

    }

 

}

Autocad plano departamento

plano de  departamento 

JAVA: FUNCIONES

 FUNCIONES

Las funciones en Java, conocidas técnicamente como métodos, son bloques de código reutilizables que realizan una tarea específica. Se definen dentro de una clase, pueden recibir parámetros (entradas), ejecutar instrucciones y opcionalmente retornar un valor usando la palabra clave 

 Sintaxis

tipoDeRetorno nombreMetodo(tipo param1, tipo param2) {

// código a ejecutar

return valor;  // opcional}

ejemplos:

1)saludar:

public class Ejemplo1 {

    static void saludar() {

        System.out.println("¡Hola, mundo!");

    }

    public static void main(String[] args) {

        saludar();  // Imprime: ¡Hola, mundo!

    }

}

2)suma de dos números

public class Ejemplo2 {

    static int sumar(int a, int b) {

        return a + b;

    }

    public static void main(String[] args) {

        int resultado = sumar(5, 3);  // resultado = 8

        System.out.println(resultado);

    }

}

void es una palabra clave en Java que indica que un método no devuelve ningún valor al terminar; solo ejecuta acciones como imprimir o modificar datos. return, por su parte, se usa en métodos no-void para devolver un valor específico al código que lo llamó, o en métodos void solo para salir prematuramente sin valor.

Ejemplos:

Ejemplo de función void:

public class EjemploVoid {

    static void saludar(String nombre) {

        System.out.println("Hola, " + nombre + "!");

        // No retorna nada

    }

    public static void main(String[] args) {

        saludar("Juan");  // Imprime: Hola, Juan!

    }

}

Ejemplo de return:

public class EjemploReturn {

    static int sumar(int a, int b) {

        return a + b;  // Devuelve la suma

    }

    public static void main(String[] args) {

        int resultado = sumar(5, 3);  // resultado = 8

        System.out.println(resultado);

    }

}

C# PILAS Y COLAS

 PILAS

 

Las pilas (Stack<T>) en C# son colecciones genéricas que siguen el principio LIFO (Last In, First Out), donde el último elemento en entrar es el primero en salir. Se definen en System.Collections.Generic, permitiendo añadir (Push), eliminar (Pop) y mirar (Peek) elementos eficientemente en tiempo

, ideales para deshacer acciones o recursividad.

bravedeveloper.com

bravedeveloper.com

 +4

Características y Operaciones Principales:

LIFO: El elemento en la cima es el primero en salir.

Push(T item): Añade un elemento a la parte superior.

Pop(): Elimina y devuelve el elemento superior.

Peek(): Devuelve el elemento superior sin eliminarlo.

Count: Obtiene el número de elementos.

Clear(): Elimina todos los elementos.

CODIGO:

using System;

 

// 1. CLASE NODO - Igual que en la cola

public class Nodo

{

    public int dato;

    public Nodo siguiente;

 

    public Nodo(int valor)

    {

        dato = valor;

        siguiente = null;

    }

}

 

// 2. CLASE PILA - Solo necesita UN puntero

public class PilaSimple

{

    private Nodo cima;  // Único puntero necesario (topo de la pila)

 

    // 3. CONSTRUCTOR

    public PilaSimple()

    {

        cima = null;    // Pila vacía

    }

 

    // 4. PUSH - Agrega a la CIMA ✓ O(1)

    public void Push(int valor)

    {

        Nodo nuevo = new Nodo(valor);    // Nuevo nodo

        nuevo.siguiente = cima;          // Apunta a la cima anterior

        cima = nuevo;                    // Nuevo nodo es la nueva cima

    }

 

    // 5. POP - Quita de la CIMA ✓ O(1)

    public int Pop()

    {

        if (cima == null)

        {

            Console.WriteLine("Pila vacía");

            return -1;

        }

 

        int valor = cima.dato;          // Guardar valor de la cima

        cima = cima.siguiente;          // Bajar una posición

        return valor;                   // Devolver elemento quitado

    }

 

    // 6. PEEK - Ver cima sin quitar

    public int Peek()

    {

        if (cima == null)

        {

            Console.WriteLine("Pila vacía");

            return -1;

        }

        return cima.dato;

    }

 

    // 7. MOSTRAR - De cima hacia abajo

    public void Mostrar()

    {

        Nodo actual = cima;

        Console.Write("Pila: ");

       

        while (actual != null)

        {

            Console.Write(actual.dato + " ← ");

            actual = actual.siguiente;

        }

        Console.WriteLine("null");

    }

}

 

// 8. PRUEBA

class Program

{

    static void Main()

    {

        PilaSimple pila = new PilaSimple();

       

        pila.Push(10);

        pila.Push(20);

        pila.Push(30);

        pila.Mostrar();  // Pila: 30 ← 20 ← 10 ← null

 

        pila.Pop();      // Quita 30

        pila.Mostrar();  // Pila: 20 ← 10 ← null

    }

}

 

APLICACIÓN DE COLAS

CLASE NODO:

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

 

namespace SISTEMA_DE_COLAS

{

    public class Nodo

    {

        public int dato;

        public Nodo siguiente;

 

        public Nodo(int valor)

        {

            dato = valor;

            siguiente = null;

        }

    }

 

}

CLASE COLAS:

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

 

namespace SISTEMA_DE_COLAS

{

    public class Cola

    {

        private Nodo inicio;

        private Nodo fin;

        private int tamaño;

 

        public Cola()

        {

            inicio = null;

            fin = null;

            tamaño = 0;

        }

 

        public void Encolar(int valor)

        {

            Nodo nuevo = new Nodo(valor);

            if (estaVacia())

            {

                inicio = nuevo;

                fin = nuevo;

            }

            else

            {

                fin.siguiente = nuevo;

                fin = nuevo;

            }

            tamaño++;

        }

 

        public int Desencolar()

        {

            if (estaVacia())

            {

                System.Windows.Forms.MessageBox.Show("¡La cola está vacía!");

                return -1;

            }

            int valor = inicio.dato;

            inicio = inicio.siguiente;

            if (inicio == null) fin = null;

            tamaño--;

            return valor;

        }

 

        public int Peek()

        {

            if (estaVacia())

            {

                System.Windows.Forms.MessageBox.Show("¡La cola está vacía!");

                return -1;

            }

            return inicio.dato;

        }

 

        public bool estaVacia() => inicio == null;

        public int Tamano() => tamaño;

 

        public string Mostrar()

        {

            if (estaVacia()) return "Cola vacía";

 

            System.Text.StringBuilder sb = new System.Text.StringBuilder();

            Nodo actual = inicio;

            while (actual != null)

            {

                sb.Append(actual.dato + " ");

                actual = actual.siguiente;

            }

            return sb.ToString().Trim();

        }

    }

 

}

FORM1:

using System;

using System.Collections.Generic;

using System.ComponentModel;

using System.Data;

using System.Drawing;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

using System.Windows.Forms;

 

namespace SISTEMA_DE_COLAS

{

    public partial class Form1 : Form

    {

        private Cola miCola;  // ← Esta línea es OBLIGATORIA

 

        public Form1()

        {

            InitializeComponent();

            miCola = new Cola();  // Inicializar la cola

            ActualizarInterfaz();

        }

 

        private void btnEncolar_Click(object sender, EventArgs e)

        {

            if (int.TryParse(txtNumero.Text, out int numero))

            {

                miCola.Encolar(numero);  // Ahora sí reconoce miCola

                txtNumero.Clear();

                ActualizarInterfaz();

            }

            else

            {

                MessageBox.Show("¡Ingrese un número válido!");

            }

        }

 

        private void btnDesencolar_Click(object sender, EventArgs e)

        {

            int resultado = miCola.Desencolar();

            if (resultado != -1)

            {

                MessageBox.Show($"Elemento removido: {resultado}");

                ActualizarInterfaz();

            }

        }

 

        private void btnPeek_Click(object sender, EventArgs e)

        {

            int primero = miCola.Peek();

            if (primero != -1)

            {

                MessageBox.Show($"Primer elemento: {primero}");

            }

        }

 

        private void btnLimpiar_Click(object sender, EventArgs e)

        {

            miCola = new Cola();  // Reinicia la cola

            ActualizarInterfaz();

        }

        private void ActualizarInterfaz()

        {

            lstCola.Items.Clear();

            lstCola.Items.Add(miCola.Mostrar());

            lblTamano.Text = $"Tamaño: {miCola.Tamano()}";

            txtNumero.Focus();

        }

    }

}